relay compatible graphql endpoint

api/Cargo.lock

···
 version = 4
 
 [[package]]
+name = "Inflector"
+version = "0.11.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fe438c63458706e03479442743baae6c88256498e6431708f6dfc520a26515d3"
+dependencies = [
+ "lazy_static",
+ "regex",
+]
+
+[[package]]
 name = "addr2line"
 version = "0.25.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "69f7f8c3906b62b754cd5326047894316021dcfe5a194c8ea52bdd94934a3457"
 
 [[package]]
+name = "ascii_utils"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71938f30533e4d95a6d17aa530939da3842c2ab6f4f84b9dae68447e4129f74a"
+
+[[package]]
+name = "async-graphql"
+version = "7.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "036618f842229ba0b89652ffe425f96c7c16a49f7e3cb23b56fca7f61fd74980"
+dependencies = [
+ "async-graphql-derive",
+ "async-graphql-parser",
+ "async-graphql-value",
+ "async-stream",
+ "async-trait",
+ "base64 0.22.1",
+ "bytes",
+ "fast_chemail",
+ "fnv",
+ "futures-channel",
+ "futures-timer",
+ "futures-util",
+ "handlebars",
+ "http",
+ "indexmap",
+ "lru",
+ "mime",
+ "multer",
+ "num-traits",
+ "pin-project-lite",
+ "regex",
+ "serde",
+ "serde_json",
+ "serde_urlencoded",
+ "static_assertions_next",
+ "tempfile",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "async-graphql-axum"
+version = "7.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8725874ecfbf399e071150b8619c4071d7b2b7a2f117e173dddef53c6bdb6bb1"
+dependencies = [
+ "async-graphql",
+ "axum",
+ "bytes",
+ "futures-util",
+ "serde_json",
+ "tokio",
+ "tokio-stream",
+ "tokio-util",
+ "tower-service",
+]
+
+[[package]]
+name = "async-graphql-derive"
+version = "7.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd45deb3dbe5da5cdb8d6a670a7736d735ba65b455328440f236dfb113727a3d"
+dependencies = [
+ "Inflector",
+ "async-graphql-parser",
+ "darling",
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "strum",
+ "syn 2.0.106",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "async-graphql-parser"
+version = "7.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60b7607e59424a35dadbc085b0d513aa54ec28160ee640cf79ec3b634eba66d3"
+dependencies = [
+ "async-graphql-value",
+ "pest",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "async-graphql-value"
+version = "7.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34ecdaff7c9cffa3614a9f9999bf9ee4c3078fe3ce4d6a6e161736b56febf2de"
+dependencies = [
+ "bytes",
+ "indexmap",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "async-stream"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b5a71a6f37880a80d1d7f19efd781e4b5de42c88f0722cc13bcb6cc2cfe8476"
+dependencies = [
+ "async-stream-impl",
+ "futures-core",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "async-stream-impl"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7c24de15d275a1ecfd47a380fb4d5ec9bfe0933f309ed5e705b775596a3574d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+]
+
+[[package]]
 name = "async-trait"
 version = "0.1.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "axum"
-version = "0.7.9"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edca88bc138befd0323b20752846e6587272d3b03b0343c8ea28a6f819e6e71f"
+checksum = "8a18ed336352031311f4e0b4dd2ff392d4fbb370777c9d18d7fc9d7359f73871"
 dependencies = [
- "async-trait",
  "axum-core",
  "axum-macros",
  "base64 0.22.1",
  "bytes",
+ "form_urlencoded",
  "futures-util",
  "http",
  "http-body",
···
  "mime",
  "percent-encoding",
  "pin-project-lite",
- "rustversion",
- "serde",
+ "serde_core",
  "serde_json",
  "serde_path_to_error",
  "serde_urlencoded",
···
 
 [[package]]
 name = "axum-core"
-version = "0.4.5"
+version = "0.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09f2bd6146b97ae3359fa0cc6d6b376d9539582c7b4220f041a33ec24c226199"
+checksum = "59446ce19cd142f8833f856eb31f3eb097812d1479ab224f54d72428ca21ea22"
 dependencies = [
- "async-trait",
  "bytes",
- "futures-util",
+ "futures-core",
  "http",
  "http-body",
  "http-body-util",
  "mime",
  "pin-project-lite",
- "rustversion",
  "sync_wrapper",
  "tower-layer",
  "tower-service",
···
 
 [[package]]
 name = "axum-extra"
-version = "0.9.6"
+version = "0.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c794b30c904f0a1c2fb7740f7df7f7972dfaa14ef6f57cb6178dc63e5dca2f04"
+checksum = "9963ff19f40c6102c76756ef0a46004c0d58957d87259fc9208ff8441c12ab96"
 dependencies = [
  "axum",
  "axum-core",
  "bytes",
- "fastrand",
+ "form_urlencoded",
  "futures-util",
  "http",
  "http-body",
  "http-body-util",
  "mime",
- "multer",
  "pin-project-lite",
- "serde",
+ "rustversion",
+ "serde_core",
  "serde_html_form",
- "tower",
+ "serde_path_to_error",
  "tower-layer",
  "tower-service",
+ "tracing",
 ]
 
 [[package]]
 name = "axum-macros"
-version = "0.4.2"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57d123550fa8d071b7255cb0cc04dc302baa6c8c4a79f55701552684d8399bce"
+checksum = "604fde5e028fea851ce1d8570bbdc034bec850d157f7569d10f347d06808c05c"
 dependencies = [
  "proc-macro2",
  "quote",
···
 version = "1.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d71b6127be86fdcfddb610f7182ac57211d4b18a3e9c82eb2d17662f2227ad6a"
+dependencies = [
+ "serde",
+]
 
 [[package]]
 name = "cbor4ii"
···
 ]
 
 [[package]]
+name = "darling"
+version = "0.20.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc7f46116c46ff9ab3eb1597a45688b6715c6e628b5c133e288e709a29bcb4ee"
+dependencies = [
+ "darling_core",
+ "darling_macro",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.20.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d00b9596d185e565c2207a0b01f8bd1a135483d02d9b7b0a54b11da8d53412e"
+dependencies = [
+ "fnv",
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim",
+ "syn 2.0.106",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.20.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead"
+dependencies = [
+ "darling_core",
+ "quote",
+ "syn 2.0.106",
+]
+
+[[package]]
 name = "data-encoding"
 version = "2.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "fast_chemail"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "495a39d30d624c2caabe6312bfead73e7717692b44e0b32df168c275a2e8e9e4"
+dependencies = [
+ "ascii_utils",
+]
+
+[[package]]
 name = "fastrand"
 version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
 
 [[package]]
+name = "futures-timer"
+version = "3.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f288b0a4f20f9a56b5d1da57e2227c661b7b16168e2f72365f57b63326e29b24"
+
+[[package]]
 name = "futures-util"
 version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "handlebars"
+version = "5.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d08485b96a0e6393e9e4d1b8d48cf74ad6c063cd905eb33f42c1ce3f0377539b"
+dependencies = [
+ "log",
+ "pest",
+ "pest_derive",
+ "serde",
+ "serde_json",
+ "thiserror 1.0.69",
+]
+
+[[package]]
 name = "hashbrown"
 version = "0.15.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "ident_case"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
+
+[[package]]
 name = "idna"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 dependencies = [
  "equivalent",
  "hashbrown 0.16.0",
+ "serde",
+ "serde_core",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "matchit"
-version = "0.7.3"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e7465ac9959cc2b1404e8e2367b43684a6d13790fe23056cc8c6c5a6b7bcb94"
+checksum = "47e1ffaa40ddd1f3ed91f717a33c8c0ee23fff369e3aa8772b9605cc1d22f4c3"
 
 [[package]]
 name = "md-5"
···
 checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
 
 [[package]]
+name = "pest"
+version = "2.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21e0a3a33733faeaf8651dfee72dd0f388f0c8e5ad496a3478fa5a922f49cfa8"
+dependencies = [
+ "memchr",
+ "thiserror 2.0.16",
+ "ucd-trie",
+]
+
+[[package]]
+name = "pest_derive"
+version = "2.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc58706f770acb1dbd0973e6530a3cff4746fb721207feb3a8a6064cd0b6c663"
+dependencies = [
+ "pest",
+ "pest_generator",
+]
+
+[[package]]
+name = "pest_generator"
+version = "2.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d4f36811dfe07f7b8573462465d5cb8965fffc2e71ae377a33aecf14c2c9a2f"
+dependencies = [
+ "pest",
+ "pest_meta",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.106",
+]
+
+[[package]]
+name = "pest_meta"
+version = "2.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42919b05089acbd0a5dcd5405fb304d17d1053847b81163d09c4ad18ce8e8420"
+dependencies = [
+ "pest",
+ "sha2",
+]
+
+[[package]]
 name = "pin-project-lite"
 version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "proc-macro-crate"
+version = "3.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "219cb19e96be00ab2e37d6e299658a0cfa83e52429179969b0f0121b4ac46983"
+dependencies = [
+ "toml_edit",
+]
+
+[[package]]
 name = "proc-macro2"
 version = "1.0.101"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "0.1.0"
 dependencies = [
  "anyhow",
+ "async-graphql",
+ "async-graphql-axum",
  "async-trait",
  "atproto-client",
  "atproto-identity",
···
  "chrono",
  "dotenvy",
  "futures-util",
+ "lazy_static",
  "redis",
  "regex",
  "reqwest",
···
 checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
 
 [[package]]
+name = "static_assertions_next"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7beae5182595e9a8b683fa98c4317f956c9a2dec3b9716990d20023cc60c766"
+
+[[package]]
 name = "stringprep"
 version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
+[[package]]
+name = "strum"
+version = "0.26.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fec0f0aef304996cf250b31b5a10dee7980c85da9d759361292b8bca5a18f06"
+dependencies = [
+ "strum_macros",
+]
+
+[[package]]
+name = "strum_macros"
+version = "0.26.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c6bee85a5a24955dc440386795aa378cd9cf82acd5f764469152d2270e581be"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "rustversion",
+ "syn 2.0.106",
+]
+
+[[package]]
 name = "subtle"
 version = "2.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "tokio-tungstenite"
-version = "0.24.0"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edc5f74e248dc973e0dbb7b74c7e0d6fcc301c694ff50049504004ef4d0cdcd9"
+checksum = "d25a406cddcc431a75d3d9afc6a7c0f7428d4891dd973e4d54c56b46127bf857"
 dependencies = [
  "futures-util",
  "log",
···
 dependencies = [
  "bytes",
  "futures-core",
+ "futures-io",
  "futures-sink",
  "pin-project-lite",
  "tokio",
···
 ]
 
 [[package]]
+name = "toml_datetime"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32f1085dec27c2b6632b04c80b3bb1b4300d6495d1e129693bdda7d91e72eec1"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.23.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3effe7c0e86fdff4f69cdd2ccc1b96f933e24811c5441d44904e8683e27184b"
+dependencies = [
+ "indexmap",
+ "toml_datetime",
+ "toml_parser",
+ "winnow",
+]
+
+[[package]]
+name = "toml_parser"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4cf893c33be71572e0e9aa6dd15e6677937abd686b066eac3f8cd3531688a627"
+dependencies = [
+ "winnow",
+]
+
+[[package]]
 name = "tower"
 version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "tungstenite"
-version = "0.24.0"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18e5b8366ee7a95b16d32197d0b2604b43a0be89dc5fac9f8e96ccafbaedda8a"
+checksum = "8628dcc84e5a09eb3d8423d6cb682965dea9133204e8fb3efee74c2a0c259442"
 dependencies = [
- "byteorder",
  "bytes",
  "data-encoding",
  "http",
  "httparse",
  "log",
- "rand 0.8.5",
+ "rand 0.9.2",
  "sha1",
- "thiserror 1.0.69",
+ "thiserror 2.0.16",
  "utf-8",
 ]
 
···
 version = "1.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1dccffe3ce07af9386bfd29e80c0ab1a8205a2fc34e4bcd40364df902cfa8f3f"
+
+[[package]]
+name = "ucd-trie"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971"
 
 [[package]]
 name = "ulid"
···
 version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
+
+[[package]]
+name = "winnow"
+version = "0.7.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf"
+dependencies = [
+ "memchr",
+]
 
 [[package]]
 name = "winreg"

api/Cargo.toml

···
 
 # HTTP client and server
 reqwest = { version = "0.12", features = ["json", "stream"] }
-axum = { version = "0.7", features = ["ws", "macros"] }
-axum-extra = { version = "0.9", features = ["form"] }
+axum = { version = "0.8", features = ["ws", "macros"] }
+axum-extra = { version = "0.10", features = ["form"] }
 tower = "0.5"
 tower-http = { version = "0.6", features = ["cors", "trace"] }
 
···
 
 # Redis for caching
 redis = { version = "0.32", features = ["tokio-comp", "connection-manager"] }
+
+# GraphQL server
+async-graphql = { version = "7.0", features = ["dynamic-schema", "dataloader"] }
+async-graphql-axum = "7.0"
+lazy_static = "1.5"

api/src/database/actors.rs

···
         .await?;
         Ok(result.rows_affected())
     }
+
+    /// Resolves actor handles to DIDs for a specific slice.
+    ///
+    /// # Arguments
+    /// * `handles` - List of handles to resolve
+    /// * `slice_uri` - AT-URI of the slice
+    ///
+    /// # Returns
+    /// Vec of DIDs corresponding to the handles
+    pub async fn resolve_handles_to_dids(
+        &self,
+        handles: &[String],
+        slice_uri: &str,
+    ) -> Result<Vec<String>, DatabaseError> {
+        if handles.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        let placeholders: Vec<String> = (1..=handles.len())
+            .map(|i| format!("${}", i))
+            .collect();
+        let query_sql = format!(
+            "SELECT DISTINCT did FROM actor WHERE handle = ANY(ARRAY[{}]) AND slice_uri = ${}",
+            placeholders.join(", "),
+            handles.len() + 1
+        );
+
+        let mut query = sqlx::query_scalar::<_, String>(&query_sql);
+        for handle in handles {
+            query = query.bind(handle);
+        }
+        query = query.bind(slice_uri);
+
+        Ok(query.fetch_all(&self.pool).await?)
+    }
 }
 
 /// Builds WHERE conditions specifically for actor queries.

api/src/graphql/dataloaders.rs

···
+//! DataLoader utilities for extracting references from records
+
+use serde_json::Value;
+
+/// Extract URI from a strongRef value
+/// strongRef format: { "$type": "com.atproto.repo.strongRef", "uri": "at://...", "cid": "..." }
+pub fn extract_uri_from_strong_ref(value: &Value) -> Option<String> {
+    if let Some(obj) = value.as_object() {
+        // Check if this is a strongRef
+        if let Some(type_val) = obj.get("$type") {
+            if type_val.as_str() == Some("com.atproto.repo.strongRef") {
+                return obj.get("uri").and_then(|u| u.as_str()).map(|s| s.to_string());
+            }
+        }
+
+        // Also support direct uri field (some lexicons might use this)
+        if let Some(uri) = obj.get("uri") {
+            if let Some(uri_str) = uri.as_str() {
+                if uri_str.starts_with("at://") {
+                    return Some(uri_str.to_string());
+                }
+            }
+        }
+    }
+
+    None
+}

api/src/graphql/handler.rs

···
+//! GraphQL HTTP handler for Axum
+
+use async_graphql::dynamic::Schema;
+use async_graphql_axum::{GraphQLRequest, GraphQLResponse};
+use axum::{
+    extract::{Query, State},
+    http::{HeaderMap, StatusCode},
+    response::Html,
+};
+use serde::Deserialize;
+use std::sync::Arc;
+use tokio::sync::RwLock;
+
+use crate::errors::AppError;
+use crate::AppState;
+
+/// Global schema cache (one schema per slice)
+/// This prevents rebuilding the schema on every request
+type SchemaCache = Arc<RwLock<std::collections::HashMap<String, Schema>>>;
+
+lazy_static::lazy_static! {
+    static ref SCHEMA_CACHE: SchemaCache = Arc::new(RwLock::new(std::collections::HashMap::new()));
+}
+
+#[derive(Deserialize, Default)]
+pub struct GraphQLParams {
+    pub slice: Option<String>,
+}
+
+/// GraphQL query handler
+/// Accepts slice URI from either query parameter (?slice=...) or HTTP header (X-Slice-Uri)
+pub async fn graphql_handler(
+    State(state): State<AppState>,
+    Query(params): Query<GraphQLParams>,
+    headers: HeaderMap,
+    req: GraphQLRequest,
+) -> Result<GraphQLResponse, (StatusCode, String)> {
+    // Get slice URI from query param or header
+    let slice_uri = params
+        .slice
+        .or_else(|| {
+            headers
+                .get("x-slice-uri")
+                .and_then(|h| h.to_str().ok())
+                .map(|s| s.to_string())
+        })
+        .ok_or_else(|| {
+            (
+                StatusCode::BAD_REQUEST,
+                "Missing slice parameter. Provide either ?slice=... query parameter or X-Slice-Uri header".to_string(),
+            )
+        })?;
+
+    let schema = match get_or_build_schema(&state, &slice_uri).await {
+        Ok(s) => s,
+        Err(e) => {
+            tracing::error!("Failed to get GraphQL schema: {:?}", e);
+            return Ok(async_graphql::Response::from_errors(vec![async_graphql::ServerError::new(
+                format!("Schema error: {:?}", e),
+                None,
+            )])
+            .into());
+        }
+    };
+
+    Ok(schema.execute(req.into_inner()).await.into())
+}
+
+/// GraphQL Playground UI handler
+/// Configures the playground with the slice URI in headers
+pub async fn graphql_playground(
+    Query(params): Query<GraphQLParams>,
+) -> Result<Html<String>, (StatusCode, String)> {
+    let slice_uri = params.slice.ok_or_else(|| {
+        (
+            StatusCode::BAD_REQUEST,
+            "Missing slice parameter. Provide ?slice=... query parameter".to_string(),
+        )
+    })?;
+
+    // Create playground with pre-configured headers
+    let playground_html = format!(
+        r#"<!DOCTYPE html>
+<html>
+<head>
+  <meta charset=utf-8 />
+  <meta name="viewport" content="user-scalable=no, initial-scale=1.0, minimum-scale=1.0, maximum-scale=1.0, minimal-ui">
+  <title>Slices GraphQL Playground</title>
+  <link rel="stylesheet" href="//cdn.jsdelivr.net/npm/graphql-playground-react/build/static/css/index.css" />
+  <link rel="shortcut icon" href="//cdn.jsdelivr.net/npm/graphql-playground-react/build/favicon.png" />
+  <script src="//cdn.jsdelivr.net/npm/graphql-playground-react/build/static/js/middleware.js"></script>
+</head>
+<body>
+  <div id="root"></div>
+  <script>
+    window.addEventListener('load', function (event) {{
+      GraphQLPlayground.init(document.getElementById('root'), {{
+        endpoint: '/graphql',
+        settings: {{
+          'request.credentials': 'omit',
+        }},
+        tabs: [{{
+          endpoint: '/graphql',
+          headers: {{
+            'X-Slice-Uri': '{}'
+          }}
+        }}]
+      }})
+    }})
+  </script>
+</body>
+</html>"#,
+        slice_uri.replace("'", "\\'").replace("\"", "\\\"")
+    );
+
+    Ok(Html(playground_html))
+}
+
+/// Gets schema from cache or builds it if not cached
+async fn get_or_build_schema(
+    state: &AppState,
+    slice_uri: &str,
+) -> Result<Schema, AppError> {
+    // Check cache first
+    {
+        let cache = SCHEMA_CACHE.read().await;
+        if let Some(schema) = cache.get(slice_uri) {
+            return Ok(schema.clone());
+        }
+    }
+
+    // Build schema
+    let schema = crate::graphql::build_graphql_schema(
+        state.database.clone(),
+        slice_uri.to_string(),
+    )
+    .await
+    .map_err(|e| AppError::Internal(format!("Failed to build GraphQL schema: {}", e)))?;
+
+    // Cache it
+    {
+        let mut cache = SCHEMA_CACHE.write().await;
+        cache.insert(slice_uri.to_string(), schema.clone());
+    }
+
+    Ok(schema)
+}

api/src/graphql/mod.rs

···
+//! GraphQL endpoint implementation for Slices
+//!
+//! This module provides a GraphQL interface to query slice records with support
+//! for joining linked records through AT Protocol strongRef references.
+
+mod schema_builder;
+mod dataloaders;
+mod types;
+pub mod handler;
+
+pub use schema_builder::build_graphql_schema;
+pub use handler::{graphql_handler, graphql_playground};

api/src/graphql/schema_builder.rs

···
+//! Dynamic GraphQL schema builder from AT Protocol lexicons
+//!
+//! This module generates GraphQL schemas at runtime based on lexicon definitions
+//! stored in the database, enabling flexible querying of slice records.
+
+use async_graphql::dynamic::{Field, FieldFuture, FieldValue, Object, Schema, Scalar, TypeRef, InputObject, InputValue, Enum, EnumItem};
+use async_graphql::{Error, Value as GraphQLValue};
+use base64::engine::general_purpose;
+use base64::Engine;
+use serde_json;
+use std::collections::HashMap;
+use std::sync::Arc;
+use tokio::sync::Mutex;
+
+use crate::database::Database;
+use crate::graphql::types::{extract_collection_fields, extract_record_key, GraphQLField, GraphQLType};
+
+/// Metadata about a collection for cross-referencing
+#[derive(Clone)]
+struct CollectionMeta {
+    nsid: String,
+    key_type: String, // "tid", "literal:self", or "any"
+    type_name: String, // GraphQL type name for this collection
+}
+
+/// Builds a dynamic GraphQL schema from lexicons for a given slice
+pub async fn build_graphql_schema(
+    database: Database,
+    slice_uri: String,
+) -> Result<Schema, String> {
+    // Fetch all lexicons for this slice
+    let lexicons = database
+        .get_lexicons_by_slice(&slice_uri)
+        .await
+        .map_err(|e| format!("Failed to load lexicons: {}", e))?;
+
+    // Build Query root type and collect all object types
+    let mut query = Object::new("Query");
+    let mut objects_to_register = Vec::new();
+
+    // First pass: collect metadata about all collections for cross-referencing
+    let mut all_collections: Vec<CollectionMeta> = Vec::new();
+    for lexicon in &lexicons {
+        let nsid = lexicon
+            .get("id")
+            .and_then(|n| n.as_str())
+            .ok_or_else(|| "Lexicon missing id".to_string())?;
+
+        let defs = lexicon
+            .get("defs")
+            .ok_or_else(|| format!("Lexicon {} missing defs", nsid))?;
+
+        let fields = extract_collection_fields(defs);
+        if !fields.is_empty() {
+            if let Some(key_type) = extract_record_key(defs) {
+                all_collections.push(CollectionMeta {
+                    nsid: nsid.to_string(),
+                    key_type,
+                    type_name: nsid_to_type_name(nsid),
+                });
+            }
+        }
+    }
+
+    // Second pass: create types and queries
+    for lexicon in &lexicons {
+        // get_lexicons_by_slice returns {lexicon: 1, id: "nsid", defs: {...}}
+        let nsid = lexicon
+            .get("id")
+            .and_then(|n| n.as_str())
+            .ok_or_else(|| "Lexicon missing id".to_string())?;
+
+        let defs = lexicon
+            .get("defs")
+            .ok_or_else(|| format!("Lexicon {} missing defs", nsid))?
+            .clone();
+
+        // Extract fields from lexicon
+        let fields = extract_collection_fields(&defs);
+
+        if !fields.is_empty() {
+            // Create a GraphQL type for this collection
+            let type_name = nsid_to_type_name(nsid);
+            let record_type = create_record_type(&type_name, &fields, database.clone(), slice_uri.clone(), &all_collections);
+
+            // Create edge and connection types for this collection (Relay standard)
+            let edge_type = create_edge_type(&type_name);
+            let connection_type = create_connection_type(&type_name);
+
+            // Collect the types to register with schema later
+            objects_to_register.push(record_type);
+            objects_to_register.push(edge_type);
+            objects_to_register.push(connection_type);
+
+            // Add query field for this collection
+            let collection_query_name = nsid_to_query_name(nsid);
+            let db_clone = database.clone();
+            let slice_clone = slice_uri.clone();
+            let nsid_clone = nsid.to_string();
+
+            let connection_type_name = format!("{}Connection", &type_name);
+            query = query.field(
+                Field::new(
+                    &collection_query_name,
+                    TypeRef::named_nn(&connection_type_name),
+                    move |ctx| {
+                        let db = db_clone.clone();
+                        let slice = slice_clone.clone();
+                        let collection = nsid_clone.clone();
+
+                        FieldFuture::new(async move {
+                            // Get Relay-standard pagination arguments
+                            let first: i32 = match ctx.args.get("first") {
+                                Some(val) => val.i64().unwrap_or(50) as i32,
+                                None => 50,
+                            };
+
+                            let after: Option<&str> = match ctx.args.get("after") {
+                                Some(val) => val.string().ok(),
+                                None => None,
+                            };
+
+                            // Parse sortBy argument
+                            let sort_by: Option<Vec<crate::models::SortField>> = match ctx.args.get("sortBy") {
+                                Some(val) => {
+                                    if let Ok(list) = val.list() {
+                                        let mut sort_fields = Vec::new();
+                                        for item in list.iter() {
+                                            if let Ok(obj) = item.object() {
+                                                let field = obj.get("field")
+                                                    .and_then(|v| v.string().ok())
+                                                    .unwrap_or("indexedAt")
+                                                    .to_string();
+                                                let direction = obj.get("direction")
+                                                    .and_then(|v| v.string().ok())
+                                                    .unwrap_or("desc")
+                                                    .to_string();
+                                                sort_fields.push(crate::models::SortField { field, direction });
+                                            }
+                                        }
+                                        Some(sort_fields)
+                                    } else {
+                                        None
+                                    }
+                                },
+                                None => None,
+                            };
+
+                            // Build where clause for this collection
+                            let mut where_clause = crate::models::WhereClause {
+                                conditions: HashMap::new(),
+                                or_conditions: None,
+                            };
+
+                            // Always filter by collection
+                            where_clause.conditions.insert(
+                                "collection".to_string(),
+                                crate::models::WhereCondition {
+                                    eq: Some(serde_json::Value::String(collection.clone())),
+                                    in_values: None,
+                                    contains: None,
+                                },
+                            );
+
+                            // Parse where argument if provided
+                            if let Some(where_val) = ctx.args.get("where") {
+                                // Try to parse as JSON object
+                                if let Ok(where_obj) = where_val.object() {
+                                    for (field_name, condition_val) in where_obj.iter() {
+                                        if let Ok(condition_obj) = condition_val.object() {
+                                            let mut where_condition = crate::models::WhereCondition {
+                                                eq: None,
+                                                in_values: None,
+                                                contains: None,
+                                            };
+
+                                            // Parse eq condition
+                                            if let Some(eq_val) = condition_obj.get("eq") {
+                                                if let Ok(eq_str) = eq_val.string() {
+                                                    where_condition.eq = Some(serde_json::Value::String(eq_str.to_string()));
+                                                } else if let Ok(eq_i64) = eq_val.i64() {
+                                                    where_condition.eq = Some(serde_json::Value::Number(eq_i64.into()));
+                                                }
+                                            }
+
+                                            // Parse in condition
+                                            if let Some(in_val) = condition_obj.get("in") {
+                                                if let Ok(in_list) = in_val.list() {
+                                                    let mut values = Vec::new();
+                                                    for item in in_list.iter() {
+                                                        if let Ok(s) = item.string() {
+                                                            values.push(serde_json::Value::String(s.to_string()));
+                                                        } else if let Ok(i) = item.i64() {
+                                                            values.push(serde_json::Value::Number(i.into()));
+                                                        }
+                                                    }
+                                                    where_condition.in_values = Some(values);
+                                                }
+                                            }
+
+                                            // Parse contains condition
+                                            if let Some(contains_val) = condition_obj.get("contains") {
+                                                if let Ok(contains_str) = contains_val.string() {
+                                                    where_condition.contains = Some(contains_str.to_string());
+                                                }
+                                            }
+
+                                            where_clause.conditions.insert(field_name.to_string(), where_condition);
+                                        }
+                                    }
+                                }
+                            }
+
+                            // Resolve actorHandle to did if present
+                            if let Some(actor_handle_condition) = where_clause.conditions.remove("actorHandle") {
+                                // Collect handles to resolve
+                                let mut handles = Vec::new();
+                                if let Some(eq_value) = &actor_handle_condition.eq {
+                                    if let Some(handle_str) = eq_value.as_str() {
+                                        handles.push(handle_str.to_string());
+                                    }
+                                }
+                                if let Some(in_values) = &actor_handle_condition.in_values {
+                                    for value in in_values {
+                                        if let Some(handle_str) = value.as_str() {
+                                            handles.push(handle_str.to_string());
+                                        }
+                                    }
+                                }
+
+                                // Resolve handles to DIDs from actor table
+                                if !handles.is_empty() {
+                                    match db.resolve_handles_to_dids(&handles, &slice).await {
+                                        Ok(dids) => {
+                                            if !dids.is_empty() {
+                                                // Replace actorHandle condition with did condition
+                                                let did_condition = if dids.len() == 1 {
+                                                    crate::models::WhereCondition {
+                                                        eq: Some(serde_json::Value::String(dids[0].clone())),
+                                                        in_values: None,
+                                                        contains: None,
+                                                    }
+                                                } else {
+                                                    crate::models::WhereCondition {
+                                                        eq: None,
+                                                        in_values: Some(dids.into_iter().map(|d| serde_json::Value::String(d)).collect()),
+                                                        contains: None,
+                                                    }
+                                                };
+                                                where_clause.conditions.insert("did".to_string(), did_condition);
+                                            }
+                                            // If no DIDs found, the query will return 0 results naturally
+                                        }
+                                        Err(_) => {
+                                            // If resolution fails, skip the condition (will return 0 results)
+                                        }
+                                    }
+                                }
+                            }
+
+                            // Query database for records
+                            let (records, next_cursor) = db
+                                .get_slice_collections_records(
+                                    &slice,
+                                    Some(first),
+                                    after,
+                                    sort_by.as_ref(),
+                                    Some(&where_clause),
+                                )
+                                .await
+                                .map_err(|e| {
+                                    Error::new(format!("Database query failed: {}", e))
+                                })?;
+
+                            // Query database for total count
+                            let total_count = db
+                                .count_slice_collections_records(&slice, Some(&where_clause))
+                                .await
+                                .map_err(|e| {
+                                    Error::new(format!("Count query failed: {}", e))
+                                })? as i32;
+
+                            // Convert records to RecordContainers
+                            let record_containers: Vec<RecordContainer> = records
+                                .into_iter()
+                                .map(|record| {
+                                    // Convert Record to IndexedRecord
+                                    let indexed_record = crate::models::IndexedRecord {
+                                        uri: record.uri,
+                                        cid: record.cid,
+                                        did: record.did,
+                                        collection: record.collection,
+                                        value: record.json,
+                                        indexed_at: record.indexed_at.to_rfc3339(),
+                                    };
+                                    RecordContainer {
+                                        record: indexed_record,
+                                    }
+                                })
+                                .collect();
+
+                            // Build Connection data
+                            let connection_data = ConnectionData {
+                                total_count,
+                                has_next_page: next_cursor.is_some(),
+                                end_cursor: next_cursor,
+                                nodes: record_containers,
+                            };
+
+                            Ok(Some(FieldValue::owned_any(connection_data)))
+                        })
+                    },
+                )
+                .argument(async_graphql::dynamic::InputValue::new(
+                    "first",
+                    TypeRef::named(TypeRef::INT),
+                ))
+                .argument(async_graphql::dynamic::InputValue::new(
+                    "after",
+                    TypeRef::named(TypeRef::STRING),
+                ))
+                .argument(async_graphql::dynamic::InputValue::new(
+                    "last",
+                    TypeRef::named(TypeRef::INT),
+                ))
+                .argument(async_graphql::dynamic::InputValue::new(
+                    "before",
+                    TypeRef::named(TypeRef::STRING),
+                ))
+                .argument(async_graphql::dynamic::InputValue::new(
+                    "sortBy",
+                    TypeRef::named_list("SortField"),
+                ))
+                .argument(async_graphql::dynamic::InputValue::new(
+                    "where",
+                    TypeRef::named("JSON"),
+                ))
+                .description(format!("Query {} records", nsid)),
+            );
+        }
+    }
+
+    // Build Mutation type
+    let mutation = create_mutation_type(database.clone(), slice_uri.clone());
+
+    // Build and return the schema
+    let mut schema_builder = Schema::build(query.type_name(), Some(mutation.type_name()), None)
+        .register(query)
+        .register(mutation);
+
+    // Register JSON scalar type for complex fields
+    let json_scalar = Scalar::new("JSON");
+    schema_builder = schema_builder.register(json_scalar);
+
+    // Register Blob type
+    let blob_type = create_blob_type();
+    schema_builder = schema_builder.register(blob_type);
+
+    // Register SyncResult type for mutations
+    let sync_result_type = create_sync_result_type();
+    schema_builder = schema_builder.register(sync_result_type);
+
+    // Register SortDirection enum
+    let sort_direction_enum = create_sort_direction_enum();
+    schema_builder = schema_builder.register(sort_direction_enum);
+
+    // Register SortField input type
+    let sort_field_input = create_sort_field_input();
+    schema_builder = schema_builder.register(sort_field_input);
+
+    // Register condition input types for where clauses
+    let string_condition_input = create_string_condition_input();
+    schema_builder = schema_builder.register(string_condition_input);
+
+    let int_condition_input = create_int_condition_input();
+    schema_builder = schema_builder.register(int_condition_input);
+
+    // Register PageInfo type
+    let page_info_type = create_page_info_type();
+    schema_builder = schema_builder.register(page_info_type);
+
+    // Register all object types
+    for obj in objects_to_register {
+        schema_builder = schema_builder.register(obj);
+    }
+
+    schema_builder
+        .finish()
+        .map_err(|e| format!("Schema build error: {:?}", e))
+}
+
+/// Container to hold record data for resolvers
+#[derive(Clone)]
+struct RecordContainer {
+    record: crate::models::IndexedRecord,
+}
+
+/// Container to hold blob data and DID for URL generation
+#[derive(Clone)]
+struct BlobContainer {
+    blob_ref: String,      // CID reference
+    mime_type: String,     // MIME type
+    size: i64,             // Size in bytes
+    did: String,           // DID for CDN URL generation
+}
+
+/// Creates a GraphQL Object type for a record collection
+fn create_record_type(
+    type_name: &str,
+    fields: &[GraphQLField],
+    database: Database,
+    slice_uri: String,
+    all_collections: &[CollectionMeta],
+) -> Object {
+    let mut object = Object::new(type_name);
+
+    // Check which field names exist in lexicon to avoid conflicts
+    let lexicon_field_names: std::collections::HashSet<&str> =
+        fields.iter().map(|f| f.name.as_str()).collect();
+
+    // Add standard AT Protocol fields only if they don't conflict with lexicon fields
+    if !lexicon_field_names.contains("uri") {
+        object = object.field(Field::new("uri", TypeRef::named_nn(TypeRef::STRING), |ctx| {
+            FieldFuture::new(async move {
+                let container = ctx.parent_value.try_downcast_ref::<RecordContainer>()?;
+                Ok(Some(GraphQLValue::from(container.record.uri.clone())))
+            })
+        }));
+    }
+
+    if !lexicon_field_names.contains("cid") {
+        object = object.field(Field::new("cid", TypeRef::named_nn(TypeRef::STRING), |ctx| {
+            FieldFuture::new(async move {
+                let container = ctx.parent_value.try_downcast_ref::<RecordContainer>()?;
+                Ok(Some(GraphQLValue::from(container.record.cid.clone())))
+            })
+        }));
+    }
+
+    if !lexicon_field_names.contains("did") {
+        object = object.field(Field::new("did", TypeRef::named_nn(TypeRef::STRING), |ctx| {
+            FieldFuture::new(async move {
+                let container = ctx.parent_value.try_downcast_ref::<RecordContainer>()?;
+                Ok(Some(GraphQLValue::from(container.record.did.clone())))
+            })
+        }));
+    }
+
+    if !lexicon_field_names.contains("indexedAt") {
+        object = object.field(Field::new(
+            "indexedAt",
+            TypeRef::named_nn(TypeRef::STRING),
+            |ctx| {
+                FieldFuture::new(async move {
+                    let container = ctx.parent_value.try_downcast_ref::<RecordContainer>()?;
+                    Ok(Some(GraphQLValue::from(
+                        container.record.indexed_at.clone(),
+                    )))
+                })
+            },
+        ));
+    }
+
+    // Add actor metadata field (handle from actors table)
+    // Always add as "actorHandle" to avoid conflicts with lexicon fields
+    let db_for_actor = database.clone();
+    let slice_for_actor = slice_uri.clone();
+    object = object.field(Field::new(
+        "actorHandle",
+        TypeRef::named(TypeRef::STRING),
+        move |ctx| {
+                let db = db_for_actor.clone();
+                let slice = slice_for_actor.clone();
+                FieldFuture::new(async move {
+                    let container = ctx.parent_value.try_downcast_ref::<RecordContainer>()?;
+                    let did = &container.record.did;
+
+                    // Build where clause to find actor by DID
+                    let mut where_clause = crate::models::WhereClause {
+                        conditions: std::collections::HashMap::new(),
+                        or_conditions: None,
+                    };
+                    where_clause.conditions.insert(
+                        "did".to_string(),
+                        crate::models::WhereCondition {
+                            eq: Some(serde_json::Value::String(did.clone())),
+                            in_values: None,
+                            contains: None,
+                        },
+                    );
+
+                    match db.get_slice_actors(&slice, Some(1), None, Some(&where_clause)).await {
+                        Ok((actors, _cursor)) => {
+                            if let Some(actor) = actors.first() {
+                                if let Some(handle) = &actor.handle {
+                                    Ok(Some(GraphQLValue::from(handle.clone())))
+                                } else {
+                                    Ok(None)
+                                }
+                            } else {
+                                Ok(None)
+                            }
+                        }
+                        Err(e) => {
+                            tracing::debug!("Actor not found for {}: {}", did, e);
+                            Ok(None)
+                        }
+                    }
+                })
+            },
+        ));
+
+    // Add fields from lexicon
+    for field in fields {
+        let field_name = field.name.clone();
+        let field_name_for_field = field_name.clone(); // Need separate clone for Field::new
+        let field_type = field.field_type.clone();
+        let db_clone = database.clone();
+
+        let type_ref = graphql_type_to_typeref(&field.field_type, field.is_required);
+
+        object = object.field(Field::new(&field_name_for_field, type_ref, move |ctx| {
+            let field_name = field_name.clone();
+            let field_type = field_type.clone();
+            let db = db_clone.clone();
+
+            FieldFuture::new(async move {
+                let container = ctx.parent_value.try_downcast_ref::<RecordContainer>()?;
+                let value = container.record.value.get(&field_name);
+
+                if let Some(val) = value {
+                    // Check for explicit null value
+                    if val.is_null() {
+                        return Ok(Some(FieldValue::NULL));
+                    }
+
+                    // Check if this is a blob field
+                    if matches!(field_type, GraphQLType::Blob) {
+                        // Extract blob fields from JSON object
+                        if let Some(obj) = val.as_object() {
+                            let blob_ref = obj
+                                .get("ref")
+                                .and_then(|r| r.as_object())
+                                .and_then(|r| r.get("$link"))
+                                .and_then(|l| l.as_str())
+                                .unwrap_or("")
+                                .to_string();
+
+                            let mime_type = obj
+                                .get("mimeType")
+                                .and_then(|m| m.as_str())
+                                .unwrap_or("image/jpeg")
+                                .to_string();
+
+                            let size = obj
+                                .get("size")
+                                .and_then(|s| s.as_i64())
+                                .unwrap_or(0);
+
+                            let blob_container = BlobContainer {
+                                blob_ref,
+                                mime_type,
+                                size,
+                                did: container.record.did.clone(),
+                            };
+
+                            return Ok(Some(FieldValue::owned_any(blob_container)));
+                        }
+
+                        // If not a proper blob object, return NULL
+                        return Ok(Some(FieldValue::NULL));
+                    }
+
+                    // Check if this is a reference field that needs joining
+                    if matches!(field_type, GraphQLType::Ref) {
+                        // Extract URI from strongRef and fetch the linked record
+                        if let Some(uri) =
+                            crate::graphql::dataloaders::extract_uri_from_strong_ref(val)
+                        {
+                            match db.get_record(&uri).await {
+                                Ok(Some(linked_record)) => {
+                                    // Convert the linked record to a JSON value
+                                    let record_json = serde_json::to_value(linked_record)
+                                        .map_err(|e| {
+                                            Error::new(format!("Serialization error: {}", e))
+                                        })?;
+
+                                    // Convert serde_json::Value to async_graphql::Value
+                                    let graphql_val = json_to_graphql_value(&record_json);
+                                    return Ok(Some(FieldValue::value(graphql_val)));
+                                }
+                                Ok(None) => {
+                                    return Ok(Some(FieldValue::NULL));
+                                }
+                                Err(e) => {
+                                    tracing::error!("Error fetching linked record: {}", e);
+                                    return Ok(Some(FieldValue::NULL));
+                                }
+                            }
+                        }
+                    }
+
+                    // For non-ref fields, return the raw JSON value
+                    let graphql_val = json_to_graphql_value(val);
+                    Ok(Some(FieldValue::value(graphql_val)))
+                } else {
+                    Ok(Some(FieldValue::NULL))
+                }
+            })
+        }));
+    }
+
+    // Add join fields for cross-referencing other collections by DID
+    for collection in all_collections {
+        let field_name = nsid_to_join_field_name(&collection.nsid);
+
+        // Skip if this would conflict with existing field
+        if lexicon_field_names.contains(field_name.as_str()) {
+            continue;
+        }
+
+        let collection_nsid = collection.nsid.clone();
+        let key_type = collection.key_type.clone();
+        let db_for_join = database.clone();
+        let slice_for_join = slice_uri.clone();
+
+        // Determine type and resolver based on key_type
+        match key_type.as_str() {
+            "literal:self" => {
+                // Single record per DID - return nullable object of the collection's type
+                object = object.field(Field::new(
+                    &field_name,
+                    TypeRef::named(&collection.type_name),
+                    move |ctx| {
+                        let db = db_for_join.clone();
+                        let nsid = collection_nsid.clone();
+                        FieldFuture::new(async move {
+                            let container = ctx.parent_value.try_downcast_ref::<RecordContainer>()?;
+                            let uri = format!("at://{}/{}/self", container.record.did, nsid);
+
+                            match db.get_record(&uri).await {
+                                Ok(Some(record)) => {
+                                    let new_container = RecordContainer {
+                                        record,
+                                    };
+                                    Ok(Some(FieldValue::owned_any(new_container)))
+                                }
+                                Ok(None) => Ok(None),
+                                Err(e) => {
+                                    tracing::debug!("Record not found for {}: {}", uri, e);
+                                    Ok(None)
+                                }
+                            }
+                        })
+                    },
+                ));
+            }
+            "tid" | "any" => {
+                // Multiple records per DID - return array of the collection's type
+                object = object.field(
+                    Field::new(
+                        &field_name,
+                        TypeRef::named_nn_list_nn(&collection.type_name),
+                        move |ctx| {
+                            let db = db_for_join.clone();
+                            let nsid = collection_nsid.clone();
+                            let slice = slice_for_join.clone();
+                            FieldFuture::new(async move {
+                                let container = ctx.parent_value.try_downcast_ref::<RecordContainer>()?;
+                                let did = &container.record.did;
+
+                                // Get limit from argument, default to 50
+                                let limit = ctx.args.get("limit")
+                                    .and_then(|v| v.i64().ok())
+                                    .map(|i| i as i32)
+                                    .unwrap_or(50)
+                                    .min(100); // Cap at 100 to prevent abuse
+
+                                // Build where clause to find all records of this collection for this DID
+                                let mut where_clause = crate::models::WhereClause {
+                                    conditions: HashMap::new(),
+                                    or_conditions: None,
+                                };
+                                where_clause.conditions.insert(
+                                    "collection".to_string(),
+                                    crate::models::WhereCondition {
+                                        eq: Some(serde_json::Value::String(nsid.clone())),
+                                        in_values: None,
+                                        contains: None,
+                                    },
+                                );
+                                where_clause.conditions.insert(
+                                    "did".to_string(),
+                                    crate::models::WhereCondition {
+                                        eq: Some(serde_json::Value::String(did.clone())),
+                                        in_values: None,
+                                        contains: None,
+                                    },
+                                );
+
+                                match db.get_slice_collections_records(
+                                    &slice,
+                                    Some(limit),
+                                    None,     // cursor
+                                    None,     // sort
+                                    Some(&where_clause),
+                                ).await {
+                                    Ok((records, _cursor)) => {
+                                        let values: Vec<FieldValue> = records
+                                            .into_iter()
+                                            .map(|record| {
+                                                // Convert Record to IndexedRecord
+                                                let indexed_record = crate::models::IndexedRecord {
+                                                    uri: record.uri,
+                                                    cid: record.cid,
+                                                    did: record.did,
+                                                    collection: record.collection,
+                                                    value: record.json,
+                                                    indexed_at: record.indexed_at.to_rfc3339(),
+                                                };
+                                                let container = RecordContainer {
+                                                    record: indexed_record,
+                                                };
+                                                FieldValue::owned_any(container)
+                                            })
+                                            .collect();
+                                        Ok(Some(FieldValue::list(values)))
+                                    }
+                                    Err(e) => {
+                                        tracing::debug!("Error querying {}: {}", nsid, e);
+                                        Ok(Some(FieldValue::list(Vec::<FieldValue>::new())))
+                                    }
+                                }
+                            })
+                        },
+                    )
+                    .argument(async_graphql::dynamic::InputValue::new(
+                        "limit",
+                        TypeRef::named(TypeRef::INT),
+                    ))
+                );
+            }
+            _ => {
+                // Unknown key type, skip
+                continue;
+            }
+        }
+    }
+
+    // Add reverse joins: for every other collection, add a field to query records by DID
+    // This enables bidirectional traversal (e.g., profile.plays and play.profile)
+    for collection in all_collections {
+        let reverse_field_name = format!("{}s", nsid_to_join_field_name(&collection.nsid));
+        let db_for_reverse = database.clone();
+        let slice_for_reverse = slice_uri.clone();
+        let collection_nsid = collection.nsid.clone();
+        let collection_type = collection.type_name.clone();
+
+        object = object.field(
+            Field::new(
+                &reverse_field_name,
+                TypeRef::named_nn_list_nn(&collection_type),
+                move |ctx| {
+                    let db = db_for_reverse.clone();
+                    let slice = slice_for_reverse.clone();
+                    let nsid = collection_nsid.clone();
+                    FieldFuture::new(async move {
+                        let container = ctx.parent_value.try_downcast_ref::<RecordContainer>()?;
+                        let did = &container.record.did;
+
+                        // Get limit from argument, default to 50
+                        let limit = ctx.args.get("limit")
+                            .and_then(|v| v.i64().ok())
+                            .map(|i| i as i32)
+                            .unwrap_or(50)
+                            .min(100); // Cap at 100 to prevent abuse
+
+                        // Build where clause to find all records of this collection for this DID
+                        let mut where_clause = crate::models::WhereClause {
+                            conditions: HashMap::new(),
+                            or_conditions: None,
+                        };
+                        where_clause.conditions.insert(
+                            "collection".to_string(),
+                            crate::models::WhereCondition {
+                                eq: Some(serde_json::Value::String(nsid.clone())),
+                                in_values: None,
+                                contains: None,
+                            },
+                        );
+                        where_clause.conditions.insert(
+                            "did".to_string(),
+                            crate::models::WhereCondition {
+                                eq: Some(serde_json::Value::String(did.clone())),
+                                in_values: None,
+                                contains: None,
+                            },
+                        );
+
+                        match db.get_slice_collections_records(
+                            &slice,
+                            Some(limit),
+                            None,     // cursor
+                            None,     // sort
+                            Some(&where_clause),
+                        ).await {
+                            Ok((records, _cursor)) => {
+                                let values: Vec<FieldValue> = records
+                                    .into_iter()
+                                    .map(|record| {
+                                        // Convert Record to IndexedRecord
+                                        let indexed_record = crate::models::IndexedRecord {
+                                            uri: record.uri,
+                                            cid: record.cid,
+                                            did: record.did,
+                                            collection: record.collection,
+                                            value: record.json,
+                                            indexed_at: record.indexed_at.to_rfc3339(),
+                                        };
+                                        let container = RecordContainer {
+                                            record: indexed_record,
+                                        };
+                                        FieldValue::owned_any(container)
+                                    })
+                                    .collect();
+                                Ok(Some(FieldValue::list(values)))
+                            }
+                            Err(e) => {
+                                tracing::debug!("Error querying {}: {}", nsid, e);
+                                Ok(Some(FieldValue::list(Vec::<FieldValue>::new())))
+                            }
+                        }
+                    })
+                },
+            )
+            .argument(async_graphql::dynamic::InputValue::new(
+                "limit",
+                TypeRef::named(TypeRef::INT),
+            ))
+        );
+    }
+
+    object
+}
+
+/// Convert serde_json::Value to async_graphql::Value
+fn json_to_graphql_value(val: &serde_json::Value) -> GraphQLValue {
+    match val {
+        serde_json::Value::Null => GraphQLValue::Null,
+        serde_json::Value::Bool(b) => GraphQLValue::Boolean(*b),
+        serde_json::Value::Number(n) => {
+            if let Some(i) = n.as_i64() {
+                GraphQLValue::Number((i as i32).into())
+            } else if let Some(f) = n.as_f64() {
+                GraphQLValue::Number(serde_json::Number::from_f64(f).unwrap().into())
+            } else {
+                GraphQLValue::Null
+            }
+        }
+        serde_json::Value::String(s) => GraphQLValue::String(s.clone()),
+        serde_json::Value::Array(arr) => {
+            GraphQLValue::List(arr.iter().map(json_to_graphql_value).collect())
+        }
+        serde_json::Value::Object(obj) => {
+            let mut map = async_graphql::indexmap::IndexMap::new();
+            for (k, v) in obj {
+                map.insert(
+                    async_graphql::Name::new(k.as_str()),
+                    json_to_graphql_value(v),
+                );
+            }
+            GraphQLValue::Object(map)
+        }
+    }
+}
+
+/// Converts GraphQL type to TypeRef for async-graphql
+fn graphql_type_to_typeref(gql_type: &GraphQLType, is_required: bool) -> TypeRef {
+    match gql_type {
+        GraphQLType::String => {
+            if is_required {
+                TypeRef::named_nn(TypeRef::STRING)
+            } else {
+                TypeRef::named(TypeRef::STRING)
+            }
+        }
+        GraphQLType::Int => {
+            if is_required {
+                TypeRef::named_nn(TypeRef::INT)
+            } else {
+                TypeRef::named(TypeRef::INT)
+            }
+        }
+        GraphQLType::Boolean => {
+            if is_required {
+                TypeRef::named_nn(TypeRef::BOOLEAN)
+            } else {
+                TypeRef::named(TypeRef::BOOLEAN)
+            }
+        }
+        GraphQLType::Float => {
+            if is_required {
+                TypeRef::named_nn(TypeRef::FLOAT)
+            } else {
+                TypeRef::named(TypeRef::FLOAT)
+            }
+        }
+        GraphQLType::Blob => {
+            // Blob object type with url resolver
+            if is_required {
+                TypeRef::named_nn("Blob")
+            } else {
+                TypeRef::named("Blob")
+            }
+        }
+        GraphQLType::Json | GraphQLType::Ref | GraphQLType::Object(_) | GraphQLType::Union => {
+            // JSON scalar type - linked records and complex objects return as JSON
+            if is_required {
+                TypeRef::named_nn("JSON")
+            } else {
+                TypeRef::named("JSON")
+            }
+        }
+        GraphQLType::Array(inner) => {
+            // For arrays of primitives, use typed arrays
+            // For arrays of complex types, use JSON scalar
+            match inner.as_ref() {
+                GraphQLType::String | GraphQLType::Int | GraphQLType::Boolean | GraphQLType::Float => {
+                    let inner_ref = match inner.as_ref() {
+                        GraphQLType::String => TypeRef::STRING,
+                        GraphQLType::Int => TypeRef::INT,
+                        GraphQLType::Boolean => TypeRef::BOOLEAN,
+                        GraphQLType::Float => TypeRef::FLOAT,
+                        _ => unreachable!(),
+                    };
+
+                    if is_required {
+                        TypeRef::named_nn_list_nn(inner_ref)
+                    } else {
+                        TypeRef::named_list(inner_ref)
+                    }
+                }
+                _ => {
+                    // Arrays of complex types (objects, etc.) are just JSON
+                    if is_required {
+                        TypeRef::named_nn("JSON")
+                    } else {
+                        TypeRef::named("JSON")
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// Creates the Blob GraphQL type with url resolver
+fn create_blob_type() -> Object {
+    let mut blob = Object::new("Blob");
+
+    // ref field - CID reference
+    blob = blob.field(Field::new("ref", TypeRef::named_nn(TypeRef::STRING), |ctx| {
+        FieldFuture::new(async move {
+            let container = ctx.parent_value.try_downcast_ref::<BlobContainer>()?;
+            Ok(Some(GraphQLValue::from(container.blob_ref.clone())))
+        })
+    }));
+
+    // mimeType field
+    blob = blob.field(Field::new("mimeType", TypeRef::named_nn(TypeRef::STRING), |ctx| {
+        FieldFuture::new(async move {
+            let container = ctx.parent_value.try_downcast_ref::<BlobContainer>()?;
+            Ok(Some(GraphQLValue::from(container.mime_type.clone())))
+        })
+    }));
+
+    // size field
+    blob = blob.field(Field::new("size", TypeRef::named_nn(TypeRef::INT), |ctx| {
+        FieldFuture::new(async move {
+            let container = ctx.parent_value.try_downcast_ref::<BlobContainer>()?;
+            Ok(Some(GraphQLValue::from(container.size as i32)))
+        })
+    }));
+
+    // url(preset) field with argument
+    blob = blob.field(
+        Field::new("url", TypeRef::named_nn(TypeRef::STRING), |ctx| {
+            FieldFuture::new(async move {
+                let container = ctx.parent_value.try_downcast_ref::<BlobContainer>()?;
+
+                // Get preset argument, default to "feed_fullsize"
+                let preset: String = match ctx.args.get("preset") {
+                    Some(val) => val.string().unwrap_or("feed_fullsize").to_string(),
+                    None => "feed_fullsize".to_string(),
+                };
+
+                // Build CDN URL: https://cdn.bsky.app/img/{preset}/plain/{did}/{cid}@jpeg
+                let cdn_base_url = "https://cdn.bsky.app/img";
+                let url = format!(
+                    "{}/{}/plain/{}/{}@jpeg",
+                    cdn_base_url,
+                    preset,
+                    container.did,
+                    container.blob_ref
+                );
+
+                Ok(Some(GraphQLValue::from(url)))
+            })
+        })
+        .argument(async_graphql::dynamic::InputValue::new(
+            "preset",
+            TypeRef::named(TypeRef::STRING),
+        ))
+        .description("Generate CDN URL for the blob with the specified preset (avatar, banner, feed_thumbnail, feed_fullsize)"),
+    );
+
+    blob
+}
+
+/// Creates the SyncResult GraphQL type for mutation responses
+fn create_sync_result_type() -> Object {
+    let mut sync_result = Object::new("SyncResult");
+
+    sync_result = sync_result.field(Field::new("success", TypeRef::named_nn(TypeRef::BOOLEAN), |ctx| {
+        FieldFuture::new(async move {
+            let value = ctx.parent_value.downcast_ref::<GraphQLValue>()
+                .ok_or_else(|| Error::new("Failed to downcast sync result"))?;
+            if let GraphQLValue::Object(obj) = value {
+                if let Some(success) = obj.get("success") {
+                    return Ok(Some(success.clone()));
+                }
+            }
+            Ok(None)
+        })
+    }));
+
+    sync_result = sync_result.field(Field::new("reposProcessed", TypeRef::named_nn(TypeRef::INT), |ctx| {
+        FieldFuture::new(async move {
+            let value = ctx.parent_value.downcast_ref::<GraphQLValue>()
+                .ok_or_else(|| Error::new("Failed to downcast sync result"))?;
+            if let GraphQLValue::Object(obj) = value {
+                if let Some(repos) = obj.get("reposProcessed") {
+                    return Ok(Some(repos.clone()));
+                }
+            }
+            Ok(None)
+        })
+    }));
+
+    sync_result = sync_result.field(Field::new("recordsSynced", TypeRef::named_nn(TypeRef::INT), |ctx| {
+        FieldFuture::new(async move {
+            let value = ctx.parent_value.downcast_ref::<GraphQLValue>()
+                .ok_or_else(|| Error::new("Failed to downcast sync result"))?;
+            if let GraphQLValue::Object(obj) = value {
+                if let Some(records) = obj.get("recordsSynced") {
+                    return Ok(Some(records.clone()));
+                }
+            }
+            Ok(None)
+        })
+    }));
+
+    sync_result = sync_result.field(Field::new("timedOut", TypeRef::named_nn(TypeRef::BOOLEAN), |ctx| {
+        FieldFuture::new(async move {
+            let value = ctx.parent_value.downcast_ref::<GraphQLValue>()
+                .ok_or_else(|| Error::new("Failed to downcast sync result"))?;
+            if let GraphQLValue::Object(obj) = value {
+                if let Some(timed_out) = obj.get("timedOut") {
+                    return Ok(Some(timed_out.clone()));
+                }
+            }
+            Ok(None)
+        })
+    }));
+
+    sync_result = sync_result.field(Field::new("message", TypeRef::named_nn(TypeRef::STRING), |ctx| {
+        FieldFuture::new(async move {
+            let value = ctx.parent_value.downcast_ref::<GraphQLValue>()
+                .ok_or_else(|| Error::new("Failed to downcast sync result"))?;
+            if let GraphQLValue::Object(obj) = value {
+                if let Some(message) = obj.get("message") {
+                    return Ok(Some(message.clone()));
+                }
+            }
+            Ok(None)
+        })
+    }));
+
+    sync_result
+}
+
+/// Creates the SortDirection enum type
+fn create_sort_direction_enum() -> Enum {
+    Enum::new("SortDirection")
+        .item(EnumItem::new("asc"))
+        .item(EnumItem::new("desc"))
+}
+
+/// Creates the SortField input type
+fn create_sort_field_input() -> InputObject {
+    InputObject::new("SortField")
+        .field(InputValue::new("field", TypeRef::named_nn(TypeRef::STRING)))
+        .field(InputValue::new(
+            "direction",
+            TypeRef::named_nn("SortDirection"),
+        ))
+}
+
+/// Creates the StringCondition input type for string field filtering
+fn create_string_condition_input() -> InputObject {
+    InputObject::new("StringCondition")
+        .field(InputValue::new("eq", TypeRef::named(TypeRef::STRING)))
+        .field(InputValue::new("in", TypeRef::named_list(TypeRef::STRING)))
+        .field(InputValue::new("contains", TypeRef::named(TypeRef::STRING)))
+}
+
+/// Creates the IntCondition input type for int field filtering
+fn create_int_condition_input() -> InputObject {
+    InputObject::new("IntCondition")
+        .field(InputValue::new("eq", TypeRef::named(TypeRef::INT)))
+        .field(InputValue::new("in", TypeRef::named_list(TypeRef::INT)))
+}
+
+/// Creates the PageInfo type for connection pagination
+fn create_page_info_type() -> Object {
+    let mut page_info = Object::new("PageInfo");
+
+    page_info = page_info.field(Field::new("hasNextPage", TypeRef::named_nn(TypeRef::BOOLEAN), |ctx| {
+        FieldFuture::new(async move {
+            let value = ctx.parent_value.downcast_ref::<GraphQLValue>()
+                .ok_or_else(|| Error::new("Failed to downcast PageInfo"))?;
+            if let GraphQLValue::Object(obj) = value {
+                if let Some(has_next) = obj.get("hasNextPage") {
+                    return Ok(Some(has_next.clone()));
+                }
+            }
+            Ok(Some(GraphQLValue::from(false)))
+        })
+    }));
+
+    page_info = page_info.field(Field::new("hasPreviousPage", TypeRef::named_nn(TypeRef::BOOLEAN), |ctx| {
+        FieldFuture::new(async move {
+            let value = ctx.parent_value.downcast_ref::<GraphQLValue>()
+                .ok_or_else(|| Error::new("Failed to downcast PageInfo"))?;
+            if let GraphQLValue::Object(obj) = value {
+                if let Some(has_prev) = obj.get("hasPreviousPage") {
+                    return Ok(Some(has_prev.clone()));
+                }
+            }
+            Ok(Some(GraphQLValue::from(false)))
+        })
+    }));
+
+    page_info = page_info.field(Field::new("startCursor", TypeRef::named(TypeRef::STRING), |ctx| {
+        FieldFuture::new(async move {
+            let value = ctx.parent_value.downcast_ref::<GraphQLValue>()
+                .ok_or_else(|| Error::new("Failed to downcast PageInfo"))?;
+            if let GraphQLValue::Object(obj) = value {
+                if let Some(cursor) = obj.get("startCursor") {
+                    return Ok(Some(cursor.clone()));
+                }
+            }
+            Ok(None)
+        })
+    }));
+
+    page_info = page_info.field(Field::new("endCursor", TypeRef::named(TypeRef::STRING), |ctx| {
+        FieldFuture::new(async move {
+            let value = ctx.parent_value.downcast_ref::<GraphQLValue>()
+                .ok_or_else(|| Error::new("Failed to downcast PageInfo"))?;
+            if let GraphQLValue::Object(obj) = value {
+                if let Some(cursor) = obj.get("endCursor") {
+                    return Ok(Some(cursor.clone()));
+                }
+            }
+            Ok(None)
+        })
+    }));
+
+    page_info
+}
+
+/// Connection data structure that holds all connection fields
+#[derive(Clone)]
+struct ConnectionData {
+    total_count: i32,
+    has_next_page: bool,
+    end_cursor: Option<String>,
+    nodes: Vec<RecordContainer>,
+}
+
+/// Edge data structure for Relay connections
+#[derive(Clone)]
+struct EdgeData {
+    node: RecordContainer,
+    cursor: String,
+}
+
+/// Creates an Edge type for a given record type
+/// Example: For "Post" creates "PostEdge" with node and cursor
+fn create_edge_type(record_type_name: &str) -> Object {
+    let edge_name = format!("{}Edge", record_type_name);
+    let mut edge = Object::new(&edge_name);
+
+    // Add node field
+    let record_type = record_type_name.to_string();
+    edge = edge.field(Field::new("node", TypeRef::named_nn(&record_type), |ctx| {
+        FieldFuture::new(async move {
+            let edge_data = ctx.parent_value.try_downcast_ref::<EdgeData>()?;
+            Ok(Some(FieldValue::owned_any(edge_data.node.clone())))
+        })
+    }));
+
+    // Add cursor field
+    edge = edge.field(Field::new("cursor", TypeRef::named_nn(TypeRef::STRING), |ctx| {
+        FieldFuture::new(async move {
+            let edge_data = ctx.parent_value.try_downcast_ref::<EdgeData>()?;
+            Ok(Some(GraphQLValue::from(edge_data.cursor.clone())))
+        })
+    }));
+
+    edge
+}
+
+/// Creates a Connection type for a given record type
+/// Example: For "Post" creates "PostConnection" with edges, pageInfo, and totalCount
+fn create_connection_type(record_type_name: &str) -> Object {
+    let connection_name = format!("{}Connection", record_type_name);
+    let mut connection = Object::new(&connection_name);
+
+    // Add totalCount field
+    connection = connection.field(Field::new("totalCount", TypeRef::named_nn(TypeRef::INT), |ctx| {
+        FieldFuture::new(async move {
+            let data = ctx.parent_value.try_downcast_ref::<ConnectionData>()?;
+            Ok(Some(GraphQLValue::from(data.total_count)))
+        })
+    }));
+
+    // Add pageInfo field
+    connection = connection.field(Field::new("pageInfo", TypeRef::named_nn("PageInfo"), |ctx| {
+        FieldFuture::new(async move {
+            let data = ctx.parent_value.try_downcast_ref::<ConnectionData>()?;
+
+            let mut page_info = async_graphql::indexmap::IndexMap::new();
+            page_info.insert(
+                async_graphql::Name::new("hasNextPage"),
+                GraphQLValue::from(data.has_next_page)
+            );
+            // For forward pagination only, hasPreviousPage is always false
+            page_info.insert(
+                async_graphql::Name::new("hasPreviousPage"),
+                GraphQLValue::from(false)
+            );
+
+            // Add startCursor (first node's cid if available)
+            if !data.nodes.is_empty() {
+                if let Some(first_record) = data.nodes.first() {
+                    let start_cursor = general_purpose::URL_SAFE_NO_PAD.encode(first_record.record.cid.clone());
+                    page_info.insert(
+                        async_graphql::Name::new("startCursor"),
+                        GraphQLValue::from(start_cursor)
+                    );
+                }
+            }
+
+            // Add endCursor
+            if let Some(ref cursor) = data.end_cursor {
+                page_info.insert(
+                    async_graphql::Name::new("endCursor"),
+                    GraphQLValue::from(cursor.clone())
+                );
+            }
+
+            Ok(Some(FieldValue::owned_any(GraphQLValue::Object(page_info))))
+        })
+    }));
+
+    // Add edges field (Relay standard)
+    let edge_type = format!("{}Edge", record_type_name);
+    connection = connection.field(Field::new("edges", TypeRef::named_nn_list_nn(&edge_type), |ctx| {
+        FieldFuture::new(async move {
+            let data = ctx.parent_value.try_downcast_ref::<ConnectionData>()?;
+
+            let field_values: Vec<FieldValue<'_>> = data.nodes.iter()
+                .map(|node| {
+                    // Use base64-encoded CID as cursor
+                    let cursor = general_purpose::URL_SAFE_NO_PAD.encode(node.record.cid.clone());
+                    let edge = EdgeData {
+                        node: node.clone(),
+                        cursor,
+                    };
+                    FieldValue::owned_any(edge)
+                })
+                .collect();
+
+            Ok(Some(FieldValue::list(field_values)))
+        })
+    }));
+
+    // Add nodes field (convenience, direct access to records without edges wrapper)
+    connection = connection.field(Field::new("nodes", TypeRef::named_nn_list_nn(record_type_name), |ctx| {
+        FieldFuture::new(async move {
+            let data = ctx.parent_value.try_downcast_ref::<ConnectionData>()?;
+
+            let field_values: Vec<FieldValue<'_>> = data.nodes.iter()
+                .map(|node| FieldValue::owned_any(node.clone()))
+                .collect();
+
+            Ok(Some(FieldValue::list(field_values)))
+        })
+    }));
+
+    connection
+}
+
+/// Creates the Mutation root type with sync operations
+fn create_mutation_type(database: Database, slice_uri: String) -> Object {
+    let mut mutation = Object::new("Mutation");
+
+    // Add syncUserCollections mutation
+    let db_clone = database.clone();
+    let slice_clone = slice_uri.clone();
+
+    mutation = mutation.field(
+        Field::new(
+            "syncUserCollections",
+            TypeRef::named_nn("SyncResult"),
+            move |ctx| {
+                let db = db_clone.clone();
+                let slice = slice_clone.clone();
+
+                FieldFuture::new(async move {
+                    let did = ctx.args.get("did")
+                        .and_then(|v| v.string().ok())
+                        .ok_or_else(|| Error::new("did argument is required"))?;
+
+                    // Create sync service and call sync_user_collections
+                    let cache_backend = crate::cache::CacheFactory::create_cache(
+                        crate::cache::CacheBackend::InMemory { ttl_seconds: None }
+                    ).await.map_err(|e| Error::new(format!("Failed to create cache: {}", e)))?;
+                    let cache = Arc::new(Mutex::new(crate::cache::SliceCache::new(cache_backend)));
+                    let sync_service = crate::sync::SyncService::with_cache(
+                        db.clone(),
+                        std::env::var("RELAY_ENDPOINT")
+                            .unwrap_or_else(|_| "https://relay1.us-west.bsky.network".to_string()),
+                        cache,
+                    );
+
+                    let result = sync_service
+                        .sync_user_collections(did, &slice, 30) // 30 second timeout
+                        .await
+                        .map_err(|e| Error::new(format!("Sync failed: {}", e)))?;
+
+                    // Convert result to GraphQL object
+                    let mut obj = async_graphql::indexmap::IndexMap::new();
+                    obj.insert(async_graphql::Name::new("success"), GraphQLValue::from(result.success));
+                    obj.insert(async_graphql::Name::new("reposProcessed"), GraphQLValue::from(result.repos_processed));
+                    obj.insert(async_graphql::Name::new("recordsSynced"), GraphQLValue::from(result.records_synced));
+                    obj.insert(async_graphql::Name::new("timedOut"), GraphQLValue::from(result.timed_out));
+                    obj.insert(async_graphql::Name::new("message"), GraphQLValue::from(result.message));
+
+                    Ok(Some(FieldValue::owned_any(GraphQLValue::Object(obj))))
+                })
+            },
+        )
+        .argument(async_graphql::dynamic::InputValue::new(
+            "did",
+            TypeRef::named_nn(TypeRef::STRING),
+        ))
+        .description("Sync user collections for a given DID")
+    );
+
+    mutation
+}
+
+/// Converts NSID to GraphQL type name
+/// Example: app.bsky.feed.post -> AppBskyFeedPost
+fn nsid_to_type_name(nsid: &str) -> String {
+    nsid.split('.')
+        .map(|part| {
+            let mut chars = part.chars();
+            match chars.next() {
+                None => String::new(),
+                Some(first) => first.to_uppercase().collect::<String>() + chars.as_str(),
+            }
+        })
+        .collect::<Vec<_>>()
+        .join("")
+}
+
+/// Converts NSID to GraphQL query name in camelCase and pluralized
+/// Example: app.bsky.feed.post -> appBskyFeedPosts
+/// Example: fm.teal.alpha.feed.play -> fmTealAlphaFeedPlays
+fn nsid_to_query_name(nsid: &str) -> String {
+    // First convert to camelCase like join fields
+    let camel_case = nsid_to_join_field_name(nsid);
+
+    // Then pluralize the end
+    if camel_case.ends_with("s") || camel_case.ends_with("x") || camel_case.ends_with("ch") || camel_case.ends_with("sh") {
+        format!("{}es", camel_case) // status -> statuses, box -> boxes
+    } else if camel_case.ends_with("y") && camel_case.len() > 1 {
+        let chars: Vec<char> = camel_case.chars().collect();
+        if chars.len() > 1 && !['a', 'e', 'i', 'o', 'u'].contains(&chars[chars.len() - 2]) {
+            format!("{}ies", &camel_case[..camel_case.len() - 1]) // party -> parties
+        } else {
+            format!("{}s", camel_case) // day -> days
+        }
+    } else {
+        format!("{}s", camel_case) // post -> posts
+    }
+}
+
+/// Converts NSID to GraphQL join field name in camelCase
+/// Example: app.bsky.actor.profile -> appBskyActorProfile
+fn nsid_to_join_field_name(nsid: &str) -> String {
+    let parts: Vec<&str> = nsid.split('.').collect();
+    if parts.is_empty() {
+        return nsid.to_string();
+    }
+
+    // First part is lowercase, rest are capitalized
+    let mut result = parts[0].to_string();
+    for part in &parts[1..] {
+        let mut chars = part.chars();
+        if let Some(first) = chars.next() {
+            result.push_str(&first.to_uppercase().collect::<String>());
+            result.push_str(chars.as_str());
+        }
+    }
+
+    result
+}

api/src/graphql/types.rs

···
+//! GraphQL type definitions and mappings from AT Protocol lexicons
+
+use serde_json::Value;
+
+/// Represents a mapped GraphQL field from a lexicon property
+#[derive(Debug, Clone)]
+pub struct GraphQLField {
+    pub name: String,
+    pub field_type: GraphQLType,
+    pub is_required: bool,
+}
+
+/// GraphQL type representation mapped from lexicon types
+#[derive(Debug, Clone)]
+pub enum GraphQLType {
+    String,
+    Int,
+    Boolean,
+    Float,
+    /// Reference to another record (for strongRef)
+    Ref,
+    /// Array of a type
+    Array(Box<GraphQLType>),
+    /// Object with nested fields
+    Object(Vec<GraphQLField>),
+    /// Union of multiple types
+    Union,
+    /// Blob reference with CDN URL support
+    Blob,
+    /// Any JSON value
+    Json,
+}
+
+/// Maps AT Protocol lexicon type to GraphQL type
+pub fn map_lexicon_type_to_graphql(
+    type_name: &str,
+    lexicon_def: &Value,
+) -> GraphQLType {
+    match type_name {
+        "string" => GraphQLType::String,
+        "integer" => GraphQLType::Int,
+        "boolean" => GraphQLType::Boolean,
+        "number" => GraphQLType::Float,
+        "bytes" => GraphQLType::String, // Base64 encoded
+        "cid-link" => GraphQLType::String,
+        "blob" => GraphQLType::Blob,
+        "unknown" => GraphQLType::Json,
+        "null" => GraphQLType::Json,
+        "ref" => {
+            // Check if this is a strongRef (link to another record)
+            let ref_name = lexicon_def
+                .get("ref")
+                .and_then(|r| r.as_str())
+                .unwrap_or("");
+
+            if ref_name == "com.atproto.repo.strongRef" {
+                GraphQLType::Ref
+            } else {
+                GraphQLType::Json
+            }
+        }
+        "array" => {
+            let items = lexicon_def.get("items");
+            let item_type = if let Some(items_obj) = items {
+                let item_type_name = items_obj
+                    .get("type")
+                    .and_then(|t| t.as_str())
+                    .unwrap_or("unknown");
+                map_lexicon_type_to_graphql(item_type_name, items_obj)
+            } else {
+                GraphQLType::Json
+            };
+            GraphQLType::Array(Box::new(item_type))
+        }
+        "object" => {
+            let properties = lexicon_def
+                .get("properties")
+                .and_then(|p| p.as_object());
+
+            let required_fields: Vec<String> = lexicon_def
+                .get("required")
+                .and_then(|r| r.as_array())
+                .map(|arr| {
+                    arr.iter()
+                        .filter_map(|v| v.as_str().map(|s| s.to_string()))
+                        .collect()
+                })
+                .unwrap_or_default();
+
+            if let Some(props) = properties {
+                let fields = props
+                    .iter()
+                    .map(|(field_name, field_def)| {
+                        let field_type_name = field_def
+                            .get("type")
+                            .and_then(|t| t.as_str())
+                            .unwrap_or("unknown");
+
+                        GraphQLField {
+                            name: field_name.clone(),
+                            field_type: map_lexicon_type_to_graphql(
+                                field_type_name,
+                                field_def,
+                            ),
+                            is_required: required_fields.contains(&field_name.to_string()),
+                        }
+                    })
+                    .collect();
+
+                GraphQLType::Object(fields)
+            } else {
+                GraphQLType::Json
+            }
+        }
+        "union" => {
+            GraphQLType::Union
+        }
+        _ => GraphQLType::Json,
+    }
+}
+
+/// Extract collection schema from lexicon definitions
+pub fn extract_collection_fields(
+    lexicon_defs: &Value,
+) -> Vec<GraphQLField> {
+    let main_def = lexicon_defs
+        .get("main")
+        .or_else(|| lexicon_defs.get("record"));
+
+    if let Some(main) = main_def {
+        let type_name = main
+            .get("type")
+            .and_then(|t| t.as_str())
+            .unwrap_or("object");
+
+        // For "record" type, the actual object definition is nested under "record" field
+        let object_def = if type_name == "record" {
+            main.get("record").unwrap_or(main)
+        } else {
+            main
+        };
+
+        if type_name == "record" || type_name == "object" {
+            let object_type_name = object_def
+                .get("type")
+                .and_then(|t| t.as_str())
+                .unwrap_or("object");
+
+            if let GraphQLType::Object(fields) = map_lexicon_type_to_graphql(object_type_name, object_def) {
+                return fields;
+            }
+        }
+    }
+
+    vec![]
+}
+
+/// Extract the record key type from lexicon definitions
+/// Returns Some("tid"), Some("literal:self"), Some("any"), or None
+pub fn extract_record_key(lexicon_defs: &Value) -> Option<String> {
+    lexicon_defs
+        .get("main")?
+        .get("key")
+        .and_then(|k| k.as_str())
+        .map(|s| s.to_string())
+}

api/src/main.rs

···
 mod cache;
 mod database;
 mod errors;
+mod graphql;
 mod jetstream;
 mod jetstream_cursor;
 mod jobs;
···
             "/xrpc/network.slices.slice.getSyncSummary",
             get(xrpc::network::slices::slice::get_sync_summary::handler),
         )
+        // GraphQL endpoint
+        .route(
+            "/graphql",
+            get(graphql::graphql_playground).post(graphql::graphql_handler),
+        )
         // Dynamic collection-specific XRPC endpoints (wildcard routes must come last)
         .route(
-            "/xrpc/*method",
+            "/xrpc/{*method}",
             get(api::xrpc_dynamic::dynamic_xrpc_handler),
         )
         .route(
-            "/xrpc/*method",
+            "/xrpc/{*method}",
             post(api::xrpc_dynamic::dynamic_xrpc_post_handler),
         )
         .layer(TraceLayer::new_for_http())

api/src/models.rs

···
     pub slice_uri: Option<String>,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct IndexedRecord {
     pub uri: String,