add fuzzy where clause to graphql queries with pg_trgm

api/migrations/012_pg_trgm_extension.sql

···
+-- Enable pg_trgm extension for fuzzy text search
+CREATE EXTENSION IF NOT EXISTS pg_trgm;

api/src/api/xrpc_dynamic.rs

···
 };
 use std::collections::HashMap;
 
-
 #[derive(Deserialize)]
 pub struct GetRecordParams {
     pub uri: String,
···
         where_conditions.insert(
             "did".to_string(),
             WhereCondition {
+                eq: Some(serde_json::Value::String(author_str.to_string())),
+                in_values: None,
+                contains: None,
+                fuzzy: None,
                 gt: None,
                 gte: None,
                 lt: None,
                 lte: None,
-                eq: Some(serde_json::Value::String(author_str.to_string())),
-                in_values: None,
-                contains: None,
             },
         );
     } else if let Some(authors_str) = params.get("authors").and_then(|v| v.as_str()) {
···
         where_conditions.insert(
             "did".to_string(),
             WhereCondition {
+                eq: None,
+                in_values: Some(authors),
+                contains: None,
+                fuzzy: None,
                 gt: None,
                 gte: None,
                 lt: None,
                 lte: None,
-                eq: None,
-                in_values: Some(authors),
-                contains: None,
             },
         );
     }
···
         where_conditions.insert(
             field.to_string(),
             WhereCondition {
+                eq: None,
+                in_values: None,
+                contains: Some(query_str.to_string()),
+                fuzzy: None,
                 gt: None,
                 gte: None,
                 lt: None,
                 lte: None,
-                eq: None,
-                in_values: None,
-                contains: Some(query_str.to_string()),
             },
         );
     }
···
     where_conditions.insert(
         "collection".to_string(),
         WhereCondition {
-                gt: None,
-                gte: None,
-                lt: None,
-                lte: None,
             eq: Some(serde_json::Value::String(collection.clone())),
             in_values: None,
             contains: None,
+            fuzzy: None,
+            gt: None,
+            gte: None,
+            lt: None,
+            lte: None,
         },
     );
 
···
                 cursor,
             };
 
-            Ok(Json(
-                serde_json::to_value(output).map_err(|_| AppError::Internal("Serialization error".to_string()))?,
-            ))
+            Ok(Json(serde_json::to_value(output).map_err(|_| {
+                AppError::Internal("Serialization error".to_string())
+            })?))
         }
         Err(_) => Err(AppError::Internal("Database error".to_string())),
     }
···
     state: AppState,
     params: serde_json::Value,
 ) -> Result<Json<serde_json::Value>, AppError> {
-    let get_params: GetRecordParams =
-        serde_json::from_value(params).map_err(|_| AppError::BadRequest("Invalid parameters".to_string()))?;
+    let get_params: GetRecordParams = serde_json::from_value(params)
+        .map_err(|_| AppError::BadRequest("Invalid parameters".to_string()))?;
 
     // First verify the collection belongs to this slice
     let slice_collections = state
···
     // Use direct database query by URI for efficiency
     match state.database.get_record(&get_params.uri).await {
         Ok(Some(record)) => {
-            let json_value =
-                serde_json::to_value(record).map_err(|_| AppError::Internal("Serialization error".to_string()))?;
+            let json_value = serde_json::to_value(record)
+                .map_err(|_| AppError::Internal("Serialization error".to_string()))?;
             Ok(Json(json_value))
         }
         Ok(None) => Err(AppError::NotFound("Record not found".to_string())),
···
     body: serde_json::Value,
 ) -> Result<Json<serde_json::Value>, AppError> {
     // Parse the JSON body into SliceRecordsParams
-    let mut records_params: SliceRecordsParams = serde_json::from_value(body).map_err(|_| AppError::BadRequest("Invalid request body".to_string()))?;
+    let mut records_params: SliceRecordsParams = serde_json::from_value(body)
+        .map_err(|_| AppError::BadRequest("Invalid request body".to_string()))?;
 
     // First verify the collection belongs to this slice
     let slice_collections = state
···
     where_clause.conditions.insert(
         "collection".to_string(),
         WhereCondition {
-                gt: None,
-                gte: None,
-                lt: None,
-                lte: None,
             eq: Some(serde_json::Value::String(collection.clone())),
             in_values: None,
             contains: None,
+            fuzzy: None,
+            gt: None,
+            gte: None,
+            lt: None,
+            lte: None,
         },
     );
     records_params.where_clause = Some(where_clause);
···
                 cursor,
             };
 
-            Ok(Json(serde_json::to_value(output).map_err(|e| AppError::Internal(format!("Serialization error: {}", e)))?))
+            Ok(Json(serde_json::to_value(output).map_err(|e| {
+                AppError::Internal(format!("Serialization error: {}", e))
+            })?))
         }
         Err(e) => Err(AppError::Internal(format!("Database error: {}", e))),
     }
···
     params: serde_json::Value,
 ) -> Result<Json<serde_json::Value>, AppError> {
     // Convert query parameters to SliceRecordsParams
-    let mut records_params: SliceRecordsParams =
-        serde_json::from_value(params).map_err(|_| AppError::BadRequest("Invalid parameters".to_string()))?;
+    let mut records_params: SliceRecordsParams = serde_json::from_value(params)
+        .map_err(|_| AppError::BadRequest("Invalid parameters".to_string()))?;
 
     // First verify the collection belongs to this slice
     let slice_collections = state
···
     where_clause.conditions.insert(
         "collection".to_string(),
         WhereCondition {
-                gt: None,
-                gte: None,
-                lt: None,
-                lte: None,
             eq: Some(collection.clone().into()),
+            in_values: None,
             contains: None,
-            in_values: None,
+            fuzzy: None,
+            gt: None,
+            gte: None,
+            lt: None,
+            lte: None,
         },
     );
     records_params.where_clause = Some(where_clause);
···
     body: serde_json::Value,
 ) -> Result<Json<serde_json::Value>, AppError> {
     // Parse the JSON body into SliceRecordsParams
-    let mut records_params: SliceRecordsParams = serde_json::from_value(body).map_err(|_| AppError::BadRequest("Invalid request body".to_string()))?;
+    let mut records_params: SliceRecordsParams = serde_json::from_value(body)
+        .map_err(|_| AppError::BadRequest("Invalid request body".to_string()))?;
 
     // First verify the collection belongs to this slice
     let slice_collections = state
···
     where_clause.conditions.insert(
         "collection".to_string(),
         WhereCondition {
-                gt: None,
-                gte: None,
-                lt: None,
-                lte: None,
             eq: Some(collection.clone().into()),
             in_values: None,
             contains: None,
+            fuzzy: None,
+            gt: None,
+            gte: None,
+            lt: None,
+            lte: None,
         },
     );
     records_params.where_clause = Some(where_clause);
···
     collection: String,
 ) -> Result<Json<serde_json::Value>, AppError> {
     // Extract and verify OAuth token
-    let token = extract_bearer_token(&headers).map_err(|_| AppError::AuthRequired("Missing bearer token".to_string()))?;
+    let token = extract_bearer_token(&headers)
+        .map_err(|_| AppError::AuthRequired("Missing bearer token".to_string()))?;
     let user_info = verify_oauth_token_cached(
         &token,
         &state.config.auth_base_url,
···
     collection: String,
 ) -> Result<Json<serde_json::Value>, AppError> {
     // Extract and verify OAuth token
-    let token = extract_bearer_token(&headers).map_err(|_| AppError::AuthRequired("Missing bearer token".to_string()))?;
+    let token = extract_bearer_token(&headers)
+        .map_err(|_| AppError::AuthRequired("Missing bearer token".to_string()))?;
     let user_info = verify_oauth_token_cached(
         &token,
         &state.config.auth_base_url,
···
     collection: String,
 ) -> Result<Json<serde_json::Value>, AppError> {
     // Extract and verify OAuth token
-    let token = extract_bearer_token(&headers).map_err(|_| AppError::AuthRequired("Missing bearer token".to_string()))?;
+    let token = extract_bearer_token(&headers)
+        .map_err(|_| AppError::AuthRequired("Missing bearer token".to_string()))?;
     let user_info = verify_oauth_token_cached(
         &token,
         &state.config.auth_base_url,
···
     let uri = format!("at://{}/{}/{}", repo, collection, rkey);
 
     // Handle cascade deletion before deleting the record
-    if let Err(e) = state.database.handle_cascade_deletion(&uri, &collection).await {
+    if let Err(e) = state
+        .database
+        .handle_cascade_deletion(&uri, &collection)
+        .await
+    {
         tracing::warn!("Cascade deletion failed for {}: {}", uri, e);
     }
 

api/src/database/actors.rs

···
         let mut param_count = 2;
 
         // Build WHERE conditions for actors (handle table columns properly)
-        let (and_conditions, or_conditions) = build_actor_where_conditions(where_clause, &mut param_count);
+        let (and_conditions, or_conditions) =
+            build_actor_where_conditions(where_clause, &mut param_count);
         where_clauses.extend(and_conditions);
 
         if !or_conditions.is_empty() {
···
             ORDER BY did ASC
             LIMIT ${}
             "#,
-            where_sql,
-            param_count
+            where_sql, param_count
         );
 
         let mut sqlx_query = sqlx::query_as::<_, Actor>(&query);
···
         Ok((records, cursor))
     }
 
-
     /// Gets all actors across all slices.
     ///
     /// # Returns
···
     ///
     /// # Returns
     /// Number of actors deleted
-    pub async fn delete_all_actors_for_slice(
-        &self,
-        slice_uri: &str,
-    ) -> Result<u64, DatabaseError> {
+    pub async fn delete_all_actors_for_slice(&self, slice_uri: &str) -> Result<u64, DatabaseError> {
         let result = sqlx::query!(
             r#"
             DELETE FROM actor
···
             return Ok(Vec::new());
         }
 
-        let placeholders: Vec<String> = (1..=handles.len())
-            .map(|i| format!("${}", i))
-            .collect();
+        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(", "),

api/src/database/cursor.rs

···
 ///
 /// # Returns
 /// Result containing DecodedCursor or error if decoding fails
-pub fn decode_cursor(cursor: &str, sort_by: Option<&Vec<SortField>>) -> Result<DecodedCursor, String> {
-    let decoded_bytes = general_purpose::URL_SAFE_NO_PAD.decode(cursor)
+pub fn decode_cursor(
+    cursor: &str,
+    sort_by: Option<&Vec<SortField>>,
+) -> Result<DecodedCursor, String> {
+    let decoded_bytes = general_purpose::URL_SAFE_NO_PAD
+        .decode(cursor)
         .map_err(|e| format!("Failed to decode base64: {}", e))?;
-    let decoded_str = String::from_utf8(decoded_bytes)
-        .map_err(|e| format!("Invalid UTF-8 in cursor: {}", e))?;
+    let decoded_str =
+        String::from_utf8(decoded_bytes).map_err(|e| format!("Invalid UTF-8 in cursor: {}", e))?;
 
     let parts: Vec<&str> = decoded_str.split('|').collect();
 
···
         .map(|s| s.to_string())
         .collect();
 
-    Ok(DecodedCursor {
-        field_values,
-        cid,
-    })
+    Ok(DecodedCursor { field_values, cid })
 }
 
 /// Builds cursor-based WHERE conditions for proper multi-field pagination.
···
         for (j, sort_field) in sort_fields.iter().enumerate().take(i) {
             let field = &sort_field.field;
             let cursor_value = &decoded_cursor.field_values[j];
-            let is_datetime = field_types.and_then(|types| types.get(j).copied()).unwrap_or(false);
+            let is_datetime = field_types
+                .and_then(|types| types.get(j).copied())
+                .unwrap_or(false);
 
             let field_ref = build_field_reference(field, is_datetime);
             let param_cast = if is_datetime { "::timestamp" } else { "" };
···
         let field = &sort_fields[i].field;
         let cursor_value = &decoded_cursor.field_values[i];
         let direction = &sort_fields[i].direction;
-        let is_datetime = field_types.and_then(|types| types.get(i).copied()).unwrap_or(false);
+        let is_datetime = field_types
+            .and_then(|types| types.get(i).copied())
+            .unwrap_or(false);
 
-        let comparison_op = if direction.to_lowercase() == "desc" { "<" } else { ">" };
+        let comparison_op = if direction.to_lowercase() == "desc" {
+            "<"
+        } else {
+            ">"
+        };
         let field_ref = build_field_reference(field, is_datetime);
         let param_cast = if is_datetime { "::timestamp" } else { "" };
 
-        clause_parts.push(format!("{} {} ${}{}", field_ref, comparison_op, param_count, param_cast));
+        clause_parts.push(format!(
+            "{} {} ${}{}",
+            field_ref, comparison_op, param_count, param_cast
+        ));
         *param_count += 1;
         bind_values.push(cursor_value.clone());
 
···
     let mut final_clause_parts = Vec::new();
     for (j, field) in sort_fields.iter().enumerate() {
         let cursor_value = &decoded_cursor.field_values[j];
-        let is_datetime = field_types.and_then(|types| types.get(j).copied()).unwrap_or(false);
+        let is_datetime = field_types
+            .and_then(|types| types.get(j).copied())
+            .unwrap_or(false);
 
         let field_ref = build_field_reference(&field.field, is_datetime);
         let param_cast = if is_datetime { "::timestamp" } else { "" };
···
 
     // CID comparison uses the direction of the last sort field
     let last_direction = &sort_fields[sort_fields.len() - 1].direction;
-    let cid_comparison_op = if last_direction.to_lowercase() == "desc" { "<" } else { ">" };
+    let cid_comparison_op = if last_direction.to_lowercase() == "desc" {
+        "<"
+    } else {
+        ">"
+    };
 
     final_clause_parts.push(format!("cid {} ${}", cid_comparison_op, param_count));
     *param_count += 1;
···
     #[test]
     fn test_generate_cursor_with_sort() {
         let record = create_test_record();
-        let sort_by = vec![
-            SortField {
-                field: "text".to_string(),
-                direction: "desc".to_string(),
-            },
-        ];
+        let sort_by = vec![SortField {
+            field: "text".to_string(),
+            direction: "desc".to_string(),
+        }];
 
         let cursor = generate_cursor_from_record(&record, Some(&sort_by));
         let decoded = general_purpose::URL_SAFE_NO_PAD.decode(&cursor).unwrap();
···
 
     #[test]
     fn test_decode_cursor_single_field() {
-        let sort_by = vec![
-            SortField {
-                field: "createdAt".to_string(),
-                direction: "desc".to_string(),
-            },
-        ];
+        let sort_by = vec![SortField {
+            field: "createdAt".to_string(),
+            direction: "desc".to_string(),
+        }];
 
         let cursor_content = "2025-01-15T12:00:00Z|bafytest123";
         let cursor = general_purpose::URL_SAFE_NO_PAD.encode(cursor_content);
···
 
         let decoded = decode_cursor(&cursor, Some(&sort_by)).unwrap();
 
-        assert_eq!(decoded.field_values, vec!["Hello world", "2025-01-15T12:00:00Z"]);
+        assert_eq!(
+            decoded.field_values,
+            vec!["Hello world", "2025-01-15T12:00:00Z"]
+        );
         assert_eq!(decoded.cid, "bafytest123");
     }
 
     #[test]
     fn test_decode_cursor_invalid_format() {
-        let sort_by = vec![
-            SortField {
-                field: "text".to_string(),
-                direction: "desc".to_string(),
-            },
-        ];
+        let sort_by = vec![SortField {
+            field: "text".to_string(),
+            direction: "desc".to_string(),
+        }];
 
         let cursor_content = "bafytest123";
         let cursor = general_purpose::URL_SAFE_NO_PAD.encode(cursor_content);
···
         assert_eq!(extract_field_value(&record, "uri"), record.uri);
         assert_eq!(extract_field_value(&record, "cid"), record.cid);
         assert_eq!(extract_field_value(&record, "did"), record.did);
-        assert_eq!(extract_field_value(&record, "collection"), record.collection);
+        assert_eq!(
+            extract_field_value(&record, "collection"),
+            record.collection
+        );
     }
 
     #[test]
···
         let record = create_test_record();
 
         assert_eq!(extract_field_value(&record, "text"), "Hello world");
-        assert_eq!(extract_field_value(&record, "createdAt"), "2025-01-15T12:00:00Z");
+        assert_eq!(
+            extract_field_value(&record, "createdAt"),
+            "2025-01-15T12:00:00Z"
+        );
     }
 
     #[test]
···
         assert_eq!(extract_field_value(&record, "nonexistent"), "NULL");
         assert_eq!(extract_field_value(&record, "nested.nonexistent"), "NULL");
     }
-}
+}

api/src/database/query_builder.rs

···
 use super::types::{SortField, WhereClause, WhereCondition};
 use crate::models::Record;
 
-
 /// Builds an ORDER BY clause with optional datetime field information.
 ///
 /// # Arguments
···
                 {
                     let field_ref = build_field_reference(field, is_datetime);
 
-                    if matches!(field.as_str(), "indexed_at" | "uri" | "cid" | "did" | "collection") {
+                    if matches!(
+                        field.as_str(),
+                        "indexed_at" | "uri" | "cid" | "did" | "collection"
+                    ) {
                         order_clauses.push(format!("{field_ref} {direction}"));
                     } else {
                         order_clauses.push(format!("{field_ref} {direction} NULLS LAST"));
···
 
 /// Builds a single SQL condition clause for a field.
 ///
-/// Supports equality (eq), array membership (in_values), and pattern matching (contains)
+/// Supports equality (eq), array membership (in_values), pattern matching (contains),
+/// fuzzy matching (fuzzy), and comparison operators (gt, gte, lt, lte)
 /// for both table columns and JSON fields with nested paths.
 ///
 /// # Arguments
 /// * `field` - Field name (table column or JSON path)
-/// * `condition` - The condition to apply (eq, in_values, or contains)
+/// * `condition` - The condition to apply
 /// * `param_count` - Mutable counter for parameter numbering
 ///
 /// # Returns
···
         };
         *param_count += 1;
         clause
+    } else if let Some(_fuzzy_value) = &condition.fuzzy {
+        let clause = match field {
+            "did" | "collection" | "uri" | "cid" => {
+                format!("{} % ${}", field, param_count)
+            }
+            "json" => {
+                format!("json::text % ${}", param_count)
+            }
+            _ => {
+                let json_path = build_json_path(field);
+                format!("({}) % ${}", json_path, param_count)
+            }
+        };
+        *param_count += 1;
+        clause
     } else if let Some(_gt_value) = &condition.gt {
         let clause = match field {
             "indexed_at" => {
···
 
 /// Binds parameters for a single condition to a sqlx query.
 ///
-/// Handles eq (single value), in_values (array), and contains (pattern) conditions.
+/// Handles eq (single value), in_values (array), contains (pattern), fuzzy (similarity), and comparison conditions.
 fn bind_single_condition<'q>(
     mut query_builder: sqlx::query::QueryAs<
         'q,
···
 
     if let Some(contains_value) = &condition.contains {
         query_builder = query_builder.bind(contains_value);
+    }
+
+    if let Some(fuzzy_value) = &condition.fuzzy {
+        query_builder = query_builder.bind(fuzzy_value);
     }
 
     if let Some(gt_value) = &condition.gt {
···
 /// # Returns
 /// Query builder with all parameters bound
 pub fn bind_where_parameters_scalar<'q, T>(
-    mut query_builder: sqlx::query::QueryScalar<
-        'q,
-        sqlx::Postgres,
-        T,
-        sqlx::postgres::PgArguments,
-    >,
+    mut query_builder: sqlx::query::QueryScalar<'q, sqlx::Postgres, T, sqlx::postgres::PgArguments>,
     where_clause: Option<&'q WhereClause>,
 ) -> sqlx::query::QueryScalar<'q, sqlx::Postgres, T, sqlx::postgres::PgArguments>
 where
···
 
 /// Recursively binds parameters from a WhereClause to a scalar query.
 fn bind_clause_recursive_scalar<'q, T>(
-    mut query_builder: sqlx::query::QueryScalar<
-        'q,
-        sqlx::Postgres,
-        T,
-        sqlx::postgres::PgArguments,
-    >,
+    mut query_builder: sqlx::query::QueryScalar<'q, sqlx::Postgres, T, sqlx::postgres::PgArguments>,
     clause: &'q WhereClause,
 ) -> sqlx::query::QueryScalar<'q, sqlx::Postgres, T, sqlx::postgres::PgArguments>
 where
···
 
 /// Binds parameters for a single condition to a sqlx scalar query.
 fn bind_single_condition_scalar<'q, T>(
-    mut query_builder: sqlx::query::QueryScalar<
-        'q,
-        sqlx::Postgres,
-        T,
-        sqlx::postgres::PgArguments,
-    >,
+    mut query_builder: sqlx::query::QueryScalar<'q, sqlx::Postgres, T, sqlx::postgres::PgArguments>,
     condition: &'q WhereCondition,
 ) -> sqlx::query::QueryScalar<'q, sqlx::Postgres, T, sqlx::postgres::PgArguments>
 where
···
         query_builder = query_builder.bind(contains_value);
     }
 
+    if let Some(fuzzy_value) = &condition.fuzzy {
+        query_builder = query_builder.bind(fuzzy_value);
+    }
+
     if let Some(gt_value) = &condition.gt {
         if let Some(str_val) = gt_value.as_str() {
             query_builder = query_builder.bind(str_val);
···
         }];
 
         let result = build_order_by_clause_with_field_info(Some(&sort_by), None);
-        assert_eq!(result, "json->>'createdAt' DESC NULLS LAST, indexed_at DESC");
+        assert_eq!(
+            result,
+            "json->>'createdAt' DESC NULLS LAST, indexed_at DESC"
+        );
     }
 
     #[test]
···
         }];
 
         let result = build_order_by_clause_with_field_info(Some(&sort_by), Some(true));
-        assert_eq!(result, "(json->>'createdAt')::timestamp DESC NULLS LAST, indexed_at DESC");
+        assert_eq!(
+            result,
+            "(json->>'createdAt')::timestamp DESC NULLS LAST, indexed_at DESC"
+        );
     }
 
     #[test]
···
         }];
 
         let result = build_order_by_clause_with_field_info(Some(&sort_by), None);
-        assert_eq!(result, "json->'author'->>'name' ASC NULLS LAST, indexed_at DESC");
+        assert_eq!(
+            result,
+            "json->'author'->>'name' ASC NULLS LAST, indexed_at DESC"
+        );
     }
 
     #[test]

api/src/database/records.rs

···
 
 use super::client::Database;
 use super::cursor::{build_cursor_where_condition, decode_cursor, generate_cursor_from_record};
-use super::query_builder::{bind_where_parameters, bind_where_parameters_scalar, build_order_by_clause_with_field_info, build_where_conditions};
+use super::query_builder::{
+    bind_where_parameters, bind_where_parameters_scalar, build_order_by_clause_with_field_info,
+    build_where_conditions,
+};
 use super::types::{SortField, WhereClause};
 use crate::errors::DatabaseError;
 use crate::models::{IndexedRecord, Record};
···
                     Ok(lexicons) => {
                         let types: Vec<bool> = sort_fields
                             .iter()
-                            .map(|field| is_field_datetime(&lexicons, collection_name, &field.field))
+                            .map(|field| {
+                                is_field_datetime(&lexicons, collection_name, &field.field)
+                            })
                             .collect();
                         Some(types)
                     }
···
         };
 
         // Get first field type for ORDER BY (for backward compatibility)
-        let primary_field_is_datetime = field_types.as_ref().and_then(|types| types.first().copied());
+        let primary_field_is_datetime = field_types
+            .as_ref()
+            .and_then(|types| types.first().copied());
 
         // Build ORDER BY clause with datetime field information
         let order_by = build_order_by_clause_with_field_info(sort_by, primary_field_is_datetime);
···
                 Ok(decoded_cursor) => {
                     // Use the datetime field information we already computed
                     let field_type_slice = field_types.as_deref();
-                    let (cursor_where, bind_values) =
-                        build_cursor_where_condition(&decoded_cursor, sort_by, &mut param_count, field_type_slice);
+                    let (cursor_where, bind_values) = build_cursor_where_condition(
+                        &decoded_cursor,
+                        sort_by,
+                        &mut param_count,
+                        field_type_slice,
+                    );
                     where_clauses.push(cursor_where);
                     cursor_bind_values = bind_values;
                 }
···
             where_clauses.push(or_clause);
         }
 
-        let where_sql = where_clauses.into_iter().filter(|clause| !clause.is_empty()).collect::<Vec<_>>().join(" AND ");
+        let where_sql = where_clauses
+            .into_iter()
+            .filter(|clause| !clause.is_empty())
+            .collect::<Vec<_>>()
+            .join(" AND ");
 
         // Assign limit parameter AFTER all other parameters
         let limit_param = param_count;
···
 
         // Only return cursor if we got a full page, indicating there might be more
         let cursor = if records.len() < limit as usize {
-            None  // Last page - no more results
+            None // Last page - no more results
         } else {
             records
                 .last()
···
             where_clauses.push(or_clause);
         }
 
-        let filtered_where_clauses: Vec<_> = where_clauses.into_iter().filter(|clause| !clause.is_empty()).collect();
+        let filtered_where_clauses: Vec<_> = where_clauses
+            .into_iter()
+            .filter(|clause| !clause.is_empty())
+            .collect();
         let where_sql = if filtered_where_clauses.is_empty() {
             String::new()
         } else {
···
                 match group_by_field {
                     crate::models::GroupByField::Simple(field) => {
                         // Check if it's a table column
-                        if matches!(field.as_str(), "did" | "collection" | "uri" | "cid" | "indexed_at") {
+                        if matches!(
+                            field.as_str(),
+                            "did" | "collection" | "uri" | "cid" | "indexed_at"
+                        ) {
                             format!("\"{}\" as field_{}", field, i)
                         } else {
                             // JSON field
···
 
                         // Check if it's a table column
                         if field == "indexed_at" {
-                            format!("date_trunc('{}', \"{}\")::text as field_{}", interval_str, field, i)
+                            format!(
+                                "date_trunc('{}', \"{}\")::text as field_{}",
+                                interval_str, field, i
+                            )
                         } else {
                             // JSON field - cast to timestamp for date_trunc, then to text
-                            format!("date_trunc('{}', (json->>'{}')::timestamp)::text as field_{}", interval_str, field, i)
+                            format!(
+                                "date_trunc('{}', (json->>'{}')::timestamp)::text as field_{}",
+                                interval_str, field, i
+                            )
                         }
                     }
                 }
···
 
         let query = format!(
             "SELECT {} FROM record{} GROUP BY {} {}  LIMIT {}",
-            select_clause, where_sql, group_by_clause.join(", "), order_by_sql, limit
+            select_clause,
+            where_sql,
+            group_by_clause.join(", "),
+            order_by_sql,
+            limit
         );
 
         tracing::debug!("Generated SQL: {}", query);
···
                     // Check if it looks like JSON (starts with [ or {)
                     if str_val.starts_with('[') || str_val.starts_with('{') {
                         // Try to parse as JSON
-                        serde_json::from_str(str_val).unwrap_or_else(|_| serde_json::Value::String(str_val.clone()))
+                        serde_json::from_str(str_val)
+                            .unwrap_or_else(|_| serde_json::Value::String(str_val.clone()))
                     } else {
                         serde_json::Value::String(str_val.clone())
                     }
···
         &self,
         slice_uri: &str,
     ) -> Result<u64, DatabaseError> {
-        let result = sqlx::query("DELETE FROM record WHERE slice_uri = $1 AND collection NOT LIKE 'network.slices.%'")
-            .bind(slice_uri)
-            .execute(&self.pool)
-            .await?;
+        let result = sqlx::query(
+            "DELETE FROM record WHERE slice_uri = $1 AND collection NOT LIKE 'network.slices.%'",
+        )
+        .bind(slice_uri)
+        .execute(&self.pool)
+        .await?;
         Ok(result.rows_affected())
     }
 
···
     /// # Arguments
     /// * `uri` - AT-URI of the deleted record
     /// * `collection` - Collection name (e.g., "network.slices.lexicon")
-    pub async fn handle_cascade_deletion(&self, uri: &str, collection: &str) -> Result<(), DatabaseError> {
+    pub async fn handle_cascade_deletion(
+        &self,
+        uri: &str,
+        collection: &str,
+    ) -> Result<(), DatabaseError> {
         match collection {
             "network.slices.lexicon" => {
                 // Get the lexicon record to extract collection name and slice URI
                 if let Ok(Some(lexicon_record)) = self.get_record(uri).await
                     && let (Some(nsid), Some(slice_uri_from_record)) = (
                         lexicon_record.value.get("nsid").and_then(|v| v.as_str()),
-                        lexicon_record.value.get("slice").and_then(|v| v.as_str())
+                        lexicon_record.value.get("slice").and_then(|v| v.as_str()),
                     )
                 {
                     // Delete all records of this collection type from the slice
-                    let deleted = self.delete_records_by_collection(slice_uri_from_record, nsid).await?;
+                    let deleted = self
+                        .delete_records_by_collection(slice_uri_from_record, nsid)
+                        .await?;
                     tracing::info!(
                         "Cascade delete: removed {} records of collection {} from slice {}",
-                        deleted, nsid, slice_uri_from_record
+                        deleted,
+                        nsid,
+                        slice_uri_from_record
                     );
                 }
             }
···
                 let records_deleted = self.delete_all_records_for_slice(slice_uri).await?;
                 tracing::info!(
                     "Cascade delete: removed {} records from slice {}",
-                    records_deleted, slice_uri
+                    records_deleted,
+                    slice_uri
                 );
 
                 // Delete all actors for this slice
-                let actors_deleted = super::client::Database::delete_all_actors_for_slice(self, slice_uri).await?;
+                let actors_deleted =
+                    super::client::Database::delete_all_actors_for_slice(self, slice_uri).await?;
                 tracing::info!(
                     "Cascade delete: removed {} actors from slice {}",
-                    actors_deleted, slice_uri
+                    actors_deleted,
+                    slice_uri
                 );
             }
             _ => {
···
             }
         })];
 
-        assert!(is_field_datetime(&lexicons, "app.bsky.feed.post", "createdAt"));
+        assert!(is_field_datetime(
+            &lexicons,
+            "app.bsky.feed.post",
+            "createdAt"
+        ));
     }
 
     #[test]
···
             }
         })];
 
-        assert!(!is_field_datetime(&lexicons, "app.bsky.feed.post", "nonexistent"));
+        assert!(!is_field_datetime(
+            &lexicons,
+            "app.bsky.feed.post",
+            "nonexistent"
+        ));
     }
 
     #[test]
···
             }
         })];
 
-        assert!(!is_field_datetime(&lexicons, "app.bsky.actor.profile", "createdAt"));
+        assert!(!is_field_datetime(
+            &lexicons,
+            "app.bsky.actor.profile",
+            "createdAt"
+        ));
     }
 
     #[test]
···
             }),
         ];
 
-        assert!(is_field_datetime(&lexicons, "app.bsky.actor.profile", "createdAt"));
+        assert!(is_field_datetime(
+            &lexicons,
+            "app.bsky.actor.profile",
+            "createdAt"
+        ));
         assert!(!is_field_datetime(&lexicons, "app.bsky.feed.post", "text"));
     }
 }

api/src/database/types.rs

···
 /// - `eq`: Exact match (field = value)
 /// - `in_values`: Array membership (field IN (...))
 /// - `contains`: Pattern matching (field ILIKE '%value%')
+/// - `fuzzy`: Fuzzy text matching (field % value)
 /// - `gt`: Greater than (field > value)
 /// - `gte`: Greater than or equal (field >= value)
 /// - `lt`: Less than (field < value)
···
     #[serde(rename = "in")]
     pub in_values: Option<Vec<Value>>,
     pub contains: Option<String>,
+    pub fuzzy: Option<String>,
     pub gt: Option<Value>,
     pub gte: Option<Value>,
     pub lt: Option<Value>,

api/src/graphql/dataloader.rs

···
     type Value = Vec<IndexedRecord>;
     type Error = Arc<String>;
 
-    async fn load(&self, keys: &[CollectionDidKey]) -> Result<HashMap<CollectionDidKey, Self::Value>, Self::Error> {
+    async fn load(
+        &self,
+        keys: &[CollectionDidKey],
+    ) -> Result<HashMap<CollectionDidKey, Self::Value>, Self::Error> {
         // Group keys by slice_uri and collection for optimal batching
         let mut grouped: HashMap<(String, String), Vec<String>> = HashMap::new();
 
···
             where_clause.conditions.insert(
                 "collection".to_string(),
                 WhereCondition {
-                gt: None,
-                gte: None,
-                lt: None,
-                lte: None,
                     eq: Some(serde_json::Value::String(collection.clone())),
                     in_values: None,
                     contains: None,
+                    fuzzy: None,
+                    gt: None,
+                    gte: None,
+                    lt: None,
+                    lte: None,
                 },
             );
 
···
             where_clause.conditions.insert(
                 "did".to_string(),
                 WhereCondition {
-                gt: None,
-                gte: None,
-                lt: None,
-                lte: None,
                     eq: None,
                     in_values: Some(
                         dids.iter()
                             .map(|did| serde_json::Value::String(did.clone()))
-                            .collect()
+                            .collect(),
                     ),
                     contains: None,
+                    fuzzy: None,
+                    gt: None,
+                    gte: None,
+                    lt: None,
+                    lte: None,
                 },
             );
 
             // Query database with no limit - load all records for batched filtering
-            match self.db.get_slice_collections_records(
-                &slice_uri,
-                None,         // No limit - load all records for this DID
-                None,         // cursor
-                None,         // sort
-                Some(&where_clause),
-            ).await {
+            match self
+                .db
+                .get_slice_collections_records(
+                    &slice_uri,
+                    None, // No limit - load all records for this DID
+                    None, // cursor
+                    None, // sort
+                    Some(&where_clause),
+                )
+                .await
+            {
                 Ok((records, _cursor)) => {
                     // Group results by DID
                     for record in records {
···
                     }
                 }
                 Err(e) => {
-                    tracing::error!("DataLoader batch query failed for {}/{}: {}", slice_uri, collection, e);
+                    tracing::error!(
+                        "DataLoader batch query failed for {}/{}: {}",
+                        slice_uri,
+                        collection,
+                        e
+                    );
                     // Return empty results for failed queries rather than failing the entire batch
                 }
             }
···
     type Value = Vec<IndexedRecord>;
     type Error = Arc<String>;
 
-    async fn load(&self, keys: &[CollectionUriKey]) -> Result<HashMap<CollectionUriKey, Self::Value>, Self::Error> {
+    async fn load(
+        &self,
+        keys: &[CollectionUriKey],
+    ) -> Result<HashMap<CollectionUriKey, Self::Value>, Self::Error> {
         // Group keys by (slice_uri, collection, reference_field) for optimal batching
         let mut grouped: HashMap<(String, String, String), Vec<String>> = HashMap::new();
 
         for key in keys {
             grouped
-                .entry((key.slice_uri.clone(), key.collection.clone(), key.reference_field.clone()))
+                .entry((
+                    key.slice_uri.clone(),
+                    key.collection.clone(),
+                    key.reference_field.clone(),
+                ))
                 .or_insert_with(Vec::new)
                 .push(key.parent_uri.clone());
         }
···
             where_clause.conditions.insert(
                 "collection".to_string(),
                 WhereCondition {
-                gt: None,
-                gte: None,
-                lt: None,
-                lte: None,
                     eq: Some(serde_json::Value::String(collection.clone())),
                     in_values: None,
                     contains: None,
+                    fuzzy: None,
+                    gt: None,
+                    gte: None,
+                    lt: None,
+                    lte: None,
                 },
             );
 
···
             where_clause.conditions.insert(
                 reference_field.clone(),
                 WhereCondition {
-                gt: None,
-                gte: None,
-                lt: None,
-                lte: None,
                     eq: None,
                     in_values: Some(
-                        parent_uris.iter()
+                        parent_uris
+                            .iter()
                             .map(|uri| serde_json::Value::String(uri.clone()))
-                            .collect()
+                            .collect(),
                     ),
                     contains: None,
+                    fuzzy: None,
+                    gt: None,
+                    gte: None,
+                    lt: None,
+                    lte: None,
                 },
             );
 
             // Query database with no limit - load all records for batched filtering
-            match self.db.get_slice_collections_records(
-                &slice_uri,
-                None,         // No limit - load all records matching parent URIs
-                None,         // cursor
-                None,         // sort
-                Some(&where_clause),
-            ).await {
+            match self
+                .db
+                .get_slice_collections_records(
+                    &slice_uri,
+                    None, // No limit - load all records matching parent URIs
+                    None, // cursor
+                    None, // sort
+                    Some(&where_clause),
+                )
+                .await
+            {
                 Ok((records, _cursor)) => {
                     // Group results by parent URI (extract from the reference field)
                     for record in records {
···
                     }
                 }
                 Err(e) => {
-                    tracing::error!("CollectionUriLoader batch query failed for {}/{}: {}", slice_uri, collection, e);
+                    tracing::error!(
+                        "CollectionUriLoader batch query failed for {}/{}: {}",
+                        slice_uri,
+                        collection,
+                        e
+                    );
                     // Return empty results for failed queries rather than failing the entire batch
                 }
             }
···
         Self {
             collection_did_loader: Arc::new(AsyncGraphQLDataLoader::new(
                 CollectionDidLoader::new(db.clone()),
-                tokio::spawn
+                tokio::spawn,
             )),
             collection_uri_loader: Arc::new(AsyncGraphQLDataLoader::new(
                 CollectionUriLoader::new(db),
-                tokio::spawn
+                tokio::spawn,
             )),
         }
     }

api/src/graphql/dataloaders.rs

···
         // 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());
+                return obj
+                    .get("uri")
+                    .and_then(|u| u.as_str())
+                    .map(|s| s.to_string());
             }
         }
 

api/src/graphql/handler.rs

···
 use async_graphql::http::{WebSocket as GraphQLWebSocket, WebSocketProtocols, WsMessage};
 use async_graphql_axum::{GraphQLRequest, GraphQLResponse};
 use axum::{
-    extract::{ws::{WebSocket, Message}, Query, State, WebSocketUpgrade},
+    extract::{
+        Query, State, WebSocketUpgrade,
+        ws::{Message, WebSocket},
+    },
     http::{HeaderMap, StatusCode},
     response::{Html, Response},
 };
-use futures_util::{StreamExt, SinkExt};
+use futures_util::{SinkExt, StreamExt};
 use serde::Deserialize;
 use std::sync::Arc;
 use tokio::sync::RwLock;
 
-use crate::errors::AppError;
 use crate::AppState;
+use crate::errors::AppError;
 use crate::graphql::GraphQLContext;
 
 /// Global schema cache (one schema per slice)
···
         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,
-            )])
+            return Ok(async_graphql::Response::from_errors(vec![
+                async_graphql::ServerError::new(format!("Schema error: {:?}", e), None),
+            ])
             .into());
         }
     };
···
 }
 
 /// Gets schema from cache or builds it if not cached
-async fn get_or_build_schema(
-    state: &AppState,
-    slice_uri: &str,
-) -> Result<Schema, AppError> {
+async fn get_or_build_schema(state: &AppState, slice_uri: &str) -> Result<Schema, AppError> {
     // Check cache first
     {
         let cache = SCHEMA_CACHE.read().await;
···
     }
 
     // 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)))?;
+    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
     {

api/src/graphql/mod.rs

···
 //! 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 dataloader;
-mod types;
+mod dataloaders;
 pub mod handler;
 pub mod pubsub;
+mod schema_builder;
+mod types;
 
-pub use schema_builder::build_graphql_schema;
-pub use handler::{graphql_handler, graphql_playground, graphql_subscription_handler};
-pub use pubsub::{RecordUpdateEvent, RecordOperation, PUBSUB};
 pub use dataloader::GraphQLContext;
+pub use handler::{graphql_handler, graphql_playground, graphql_subscription_handler};
+pub use pubsub::{PUBSUB, RecordOperation, RecordUpdateEvent};
+pub use schema_builder::build_graphql_schema;

api/src/graphql/pubsub.rs

···
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::sync::Arc;
-use tokio::sync::{broadcast, RwLock};
+use tokio::sync::{RwLock, broadcast};
 use tracing::{debug, info};
 
 /// Event broadcast when a record is created or updated
···
     Update,
     Delete,
 }
-
 
 /// PubSub manager for broadcasting events to subscribers
 ///

api/src/graphql/schema_builder.rs

···
 //! 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, Subscription, SubscriptionField, SubscriptionFieldFuture};
+use async_graphql::dynamic::{
+    Enum, EnumItem, Field, FieldFuture, FieldValue, InputObject, InputValue, Object, Scalar,
+    Schema, Subscription, SubscriptionField, SubscriptionFieldFuture, TypeRef,
+};
 use async_graphql::{Error, Value as GraphQLValue};
-use base64::engine::general_purpose;
 use base64::Engine;
+use base64::engine::general_purpose;
 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};
 use crate::graphql::PUBSUB;
 use crate::graphql::dataloader::GraphQLContext;
+use crate::graphql::types::{
+    GraphQLField, GraphQLType, extract_collection_fields, extract_record_key,
+};
 
 /// 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
+    key_type: String,           // "tid", "literal:self", or "any"
+    type_name: String,          // GraphQL type name for this collection
     at_uri_fields: Vec<String>, // Fields with format "at-uri" for reverse joins
 }
 
 /// 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> {
+pub async fn build_graphql_schema(database: Database, slice_uri: String) -> Result<Schema, String> {
     // Fetch all lexicons for this slice
     let all_lexicons = database
         .get_lexicons_by_slice(&slice_uri)
···
         if !fields.is_empty() {
             if let Some(key_type) = extract_record_key(defs) {
                 // Extract at-uri field names for reverse joins
-                let at_uri_fields: Vec<String> = fields.iter()
+                let at_uri_fields: Vec<String> = fields
+                    .iter()
                     .filter(|f| f.format.as_deref() == Some("at-uri"))
                     .map(|f| f.name.clone())
                     .collect();
 
                 if !at_uri_fields.is_empty() {
-                    tracing::debug!(
-                        "Collection {} has at-uri fields: {:?}",
-                        nsid,
-                        at_uri_fields
-                    );
+                    tracing::debug!("Collection {} has at-uri fields: {:?}", nsid, at_uri_fields);
                 }
 
                 all_collections.push(CollectionMeta {
···
         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);
+            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);
···
 
             for (field_name, filter_type) in system_fields {
                 if !lexicon_field_names.contains(field_name) {
-                    where_input = where_input.field(InputValue::new(field_name, TypeRef::named(filter_type)));
+                    where_input =
+                        where_input.field(InputValue::new(field_name, TypeRef::named(filter_type)));
                 }
             }
 
···
                     GraphQLType::Int => "IntFilter",
                     _ => "StringFilter", // Default to StringFilter for strings and other types
                 };
-                where_input = where_input.field(InputValue::new(&field.name, TypeRef::named(filter_type)));
+                where_input =
+                    where_input.field(InputValue::new(&field.name, TypeRef::named(filter_type)));
             }
 
             // Add nested and/or support
             where_input = where_input
-                .field(InputValue::new("and", TypeRef::named_list(format!("{}WhereInput", type_name))))
-                .field(InputValue::new("or", TypeRef::named_list(format!("{}WhereInput", type_name))));
+                .field(InputValue::new(
+                    "and",
+                    TypeRef::named_list(format!("{}WhereInput", type_name)),
+                ))
+                .field(InputValue::new(
+                    "or",
+                    TypeRef::named_list(format!("{}WhereInput", type_name)),
+                ));
 
             // Create GroupByField enum for this collection
             let mut group_by_enum = Enum::new(format!("{}GroupByField", type_name));
···
 
             // Create collection-specific GroupByFieldInput
             let group_by_input = InputObject::new(format!("{}GroupByFieldInput", type_name))
-                .field(InputValue::new("field", TypeRef::named_nn(format!("{}GroupByField", type_name))))
+                .field(InputValue::new(
+                    "field",
+                    TypeRef::named_nn(format!("{}GroupByField", type_name)),
+                ))
                 .field(InputValue::new("interval", TypeRef::named("DateInterval")));
 
             // Create collection-specific SortFieldInput
             let sort_field_input = InputObject::new(format!("{}SortFieldInput", type_name))
-                .field(InputValue::new("field", TypeRef::named_nn(format!("{}GroupByField", type_name))))
-                .field(InputValue::new("direction", TypeRef::named("SortDirection")));
+                .field(InputValue::new(
+                    "field",
+                    TypeRef::named_nn(format!("{}GroupByField", type_name)),
+                ))
+                .field(InputValue::new(
+                    "direction",
+                    TypeRef::named("SortDirection"),
+                ));
 
             // Collect the types to register with schema later
             objects_to_register.push(record_type);
···
                             };
 
                             // Parse sortBy argument
-                            let sort_by: Option<Vec<crate::models::SortField>> = match ctx.args.get("sortBy") {
+                            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.enum_name().ok().map(|s| s.to_string()))
+                                                let field = obj
+                                                    .get("field")
+                                                    .and_then(|v| {
+                                                        v.enum_name().ok().map(|s| s.to_string())
+                                                    })
                                                     .unwrap_or_else(|| "indexedAt".to_string());
-                                                let direction = obj.get("direction")
-                                                    .and_then(|v| v.enum_name().ok().map(|s| s.to_string()))
+                                                let direction = obj
+                                                    .get("direction")
+                                                    .and_then(|v| {
+                                                        v.enum_name().ok().map(|s| s.to_string())
+                                                    })
                                                     .unwrap_or_else(|| "desc".to_string());
-                                                sort_fields.push(crate::models::SortField { field, direction });
+                                                sort_fields.push(crate::models::SortField {
+                                                    field,
+                                                    direction,
+                                                });
                                             }
                                         }
                                         Some(sort_fields)
                                     } else {
                                         None
                                     }
-                                },
+                                }
                                 None => None,
                             };
 
···
                             where_clause.conditions.insert(
                                 "collection".to_string(),
                                 crate::models::WhereCondition {
-                gt: None,
-                gte: None,
-                lt: None,
-                lte: None,
+                                    gt: None,
+                                    gte: None,
+                                    lt: None,
+                                    lte: None,
                                     eq: Some(serde_json::Value::String(collection.clone())),
                                     in_values: None,
                                     contains: None,
+                                    fuzzy: None,
                                 },
                             );
 
···
                             }
 
                             // Resolve actorHandle to did if present
-                            if let Some(actor_handle_condition) = where_clause.conditions.remove("actorHandle") {
+                            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 {
···
                                                 // Replace actorHandle condition with did condition
                                                 let did_condition = if dids.len() == 1 {
                                                     crate::models::WhereCondition {
-                gt: None,
-                gte: None,
-                lt: None,
-                lte: None,
-                                                        eq: Some(serde_json::Value::String(dids[0].clone())),
+                                                        gt: None,
+                                                        gte: None,
+                                                        lt: None,
+                                                        lte: None,
+                                                        eq: Some(serde_json::Value::String(
+                                                            dids[0].clone(),
+                                                        )),
                                                         in_values: None,
                                                         contains: None,
+                                                        fuzzy: None,
                                                     }
                                                 } else {
                                                     crate::models::WhereCondition {
-                gt: None,
-                gte: None,
-                lt: None,
-                lte: None,
+                                                        gt: None,
+                                                        gte: None,
+                                                        lt: None,
+                                                        lte: None,
                                                         eq: None,
-                                                        in_values: Some(dids.into_iter().map(|d| serde_json::Value::String(d)).collect()),
+                                                        in_values: Some(
+                                                            dids.into_iter()
+                                                                .map(|d| {
+                                                                    serde_json::Value::String(d)
+                                                                })
+                                                                .collect(),
+                                                        ),
                                                         contains: None,
+                                                        fuzzy: None,
                                                     }
                                                 };
-                                                where_clause.conditions.insert("did".to_string(), did_condition);
+                                                where_clause
+                                                    .conditions
+                                                    .insert("did".to_string(), did_condition);
                                             }
                                             // If no DIDs found, the query will return 0 results naturally
                                         }
···
                                     Some(&where_clause),
                                 )
                                 .await
-                                .map_err(|e| {
-                                    Error::new(format!("Database query failed: {}", e))
-                                })?;
+                                .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;
+                                .map_err(|e| Error::new(format!("Count query failed: {}", e)))?
+                                as i32;
 
                             // Convert records to RecordContainers
                             let record_containers: Vec<RecordContainer> = records
···
                                     eq: Some(serde_json::Value::String(collection.clone())),
                                     in_values: None,
                                     contains: None,
+                    fuzzy: None,
                                 },
                             );
 
···
                                                         eq: Some(serde_json::Value::String(dids[0].clone())),
                                                         in_values: None,
                                                         contains: None,
+                    fuzzy: None,
                                                     }
                                                 } else {
                                                     crate::models::WhereCondition {
···
                                                         eq: None,
                                                         in_values: Some(dids.into_iter().map(|d| serde_json::Value::String(d)).collect()),
                                                         contains: None,
+                    fuzzy: None,
                                                     }
                                                 };
                                                 where_clause.conditions.insert("did".to_string(), did_condition);
···
     let subscription = create_subscription_type(slice_uri.clone(), &lexicons);
 
     // Build and return the schema with complexity limits
-    let mut schema_builder = Schema::build(query.type_name(), Some(mutation.type_name()), Some(subscription.type_name()))
-        .register(query)
-        .register(mutation)
-        .register(subscription)
-        .limit_depth(50) // Higher limit to support GraphiQL introspection with reverse joins
-        .limit_complexity(5000); // Prevent expensive deeply nested queries
+    let mut schema_builder = Schema::build(
+        query.type_name(),
+        Some(mutation.type_name()),
+        Some(subscription.type_name()),
+    )
+    .register(query)
+    .register(mutation)
+    .register(subscription)
+    .limit_depth(50) // Higher limit to support GraphiQL introspection with reverse joins
+    .limit_complexity(5000); // Prevent expensive deeply nested queries
 
     // Register JSON scalar type for complex fields
     let json_scalar = Scalar::new("JSON");
···
         .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)))
+        .field(InputValue::new("fuzzy", TypeRef::named(TypeRef::STRING)))
         .field(InputValue::new("gt", TypeRef::named(TypeRef::STRING)))
         .field(InputValue::new("gte", TypeRef::named(TypeRef::STRING)))
         .field(InputValue::new("lt", TypeRef::named(TypeRef::STRING)))
···
 /// 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
+    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
···
 
     // 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())))
-            })
-        }));
+        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())))
-            })
-        }));
+        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())))
-            })
-        }));
+        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") {
···
         "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;
+            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,
-                        and: None,
-                        or: None,
-                    };
-                    where_clause.conditions.insert(
-                        "did".to_string(),
-                        crate::models::WhereCondition {
-                gt: None,
-                gte: None,
-                lt: None,
-                lte: None,
-                            eq: Some(serde_json::Value::String(did.clone())),
-                            in_values: None,
-                            contains: None,
-                        },
-                    );
+                // Build where clause to find actor by DID
+                let mut where_clause = crate::models::WhereClause {
+                    conditions: std::collections::HashMap::new(),
+                    or_conditions: None,
+                    and: None,
+                    or: None,
+                };
+                where_clause.conditions.insert(
+                    "did".to_string(),
+                    crate::models::WhereCondition {
+                        gt: None,
+                        gte: None,
+                        lt: None,
+                        lte: None,
+                        eq: Some(serde_json::Value::String(did.clone())),
+                        in_values: None,
+                        contains: None,
+                        fuzzy: 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)
-                                }
+                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)
                             }
-                        }
-                        Err(e) => {
-                            tracing::debug!("Actor not found for {}: {}", did, e);
+                        } else {
                             Ok(None)
                         }
                     }
-                })
-            },
-        ));
+                    Err(e) => {
+                        tracing::debug!("Actor not found for {}: {}", did, e);
+                        Ok(None)
+                    }
+                }
+            })
+        },
+    ));
 
     // Add fields from lexicon
     for field in fields {
···
                                             .unwrap_or("image/jpeg")
                                             .to_string();
 
-                                        let size = obj
-                                            .get("size")
-                                            .and_then(|s| s.as_i64())
-                                            .unwrap_or(0);
+                                        let size =
+                                            obj.get("size").and_then(|s| s.as_i64()).unwrap_or(0);
 
                                         let blob_container = BlobContainer {
                                             blob_ref,
···
                                 .unwrap_or("image/jpeg")
                                 .to_string();
 
-                            let size = obj
-                                .get("size")
-                                .and_then(|s| s.as_i64())
-                                .unwrap_or(0);
+                            let size = obj.get("size").and_then(|s| s.as_i64()).unwrap_or(0);
 
                             let blob_container = BlobContainer {
                                 blob_ref,
···
                             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| {
+                                    let record_json =
+                                        serde_json::to_value(linked_record).map_err(|e| {
                                             Error::new(format!("Serialization error: {}", e))
                                         })?;
 
···
 
         // Collect all string fields with format "at-uri" that might reference this collection
         // We'll check each one at runtime to see if it contains a URI to this collection
-        let uri_ref_fields: Vec<_> = fields.iter()
+        let uri_ref_fields: Vec<_> = fields
+            .iter()
             .filter(|f| matches!(f.format.as_deref(), Some("at-uri")))
             .collect();
 
···
 
         // If we found at-uri fields, create a resolver that checks each one at runtime
         if !uri_ref_fields.is_empty() {
-            let ref_field_names: Vec<String> = uri_ref_fields.iter().map(|f| f.name.clone()).collect();
+            let ref_field_names: Vec<String> =
+                uri_ref_fields.iter().map(|f| f.name.clone()).collect();
             let db_for_uri_join = database.clone();
             let target_collection = collection_nsid.clone();
 
···
                                         match db.get_record(uri).await {
                                             Ok(Some(record)) => {
                                                 let new_container = RecordContainer { record };
-                                                return Ok(Some(FieldValue::owned_any(new_container)));
+                                                return Ok(Some(FieldValue::owned_any(
+                                                    new_container,
+                                                )));
                                             }
                                             Ok(None) => continue, // Try next field
-                                            Err(_) => continue, // Try next field
+                                            Err(_) => continue,   // Try next field
                                         }
                                     }
                                 }
···
                         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 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,
-                                    };
+                                    let new_container = RecordContainer { record };
                                     Ok(Some(FieldValue::owned_any(new_container)))
                                 }
                                 Ok(None) => Ok(None),
···
                                             eq: Some(serde_json::Value::String(nsid.clone())),
                                             in_values: None,
                                             contains: None,
+                    fuzzy: None,
                                         },
                                     );
                                     where_clause.conditions.insert(
···
                                             eq: Some(serde_json::Value::String(did.clone())),
                                             in_values: None,
                                             contains: None,
+                    fuzzy: None,
                                         },
                                     );
 
···
         let collection_for_count = collection.nsid.clone();
         let at_uri_fields_for_count = collection.at_uri_fields.clone();
 
-        object = object.field(
-            Field::new(
-                &count_field_name,
-                TypeRef::named_nn(TypeRef::INT),
-                move |ctx| {
-                    let slice = slice_for_count.clone();
-                    let nsid = collection_for_count.clone();
-                    let db = db_for_count.clone();
-                    let ref_fields = at_uri_fields_for_count.clone();
-                    FieldFuture::new(async move {
-                        let container = ctx.parent_value.try_downcast_ref::<RecordContainer>()?;
-                        let parent_uri = &container.record.uri;
+        object = object.field(Field::new(
+            &count_field_name,
+            TypeRef::named_nn(TypeRef::INT),
+            move |ctx| {
+                let slice = slice_for_count.clone();
+                let nsid = collection_for_count.clone();
+                let db = db_for_count.clone();
+                let ref_fields = at_uri_fields_for_count.clone();
+                FieldFuture::new(async move {
+                    let container = ctx.parent_value.try_downcast_ref::<RecordContainer>()?;
+                    let parent_uri = &container.record.uri;
 
-                        // Build where clause to count records referencing this URI
-                        for ref_field in &ref_fields {
-                            let mut where_clause = crate::models::WhereClause {
-                                conditions: HashMap::new(),
-                                or_conditions: None,
-                                and: None,
-                                or: None,
-                            };
+                    // Build where clause to count records referencing this URI
+                    for ref_field in &ref_fields {
+                        let mut where_clause = crate::models::WhereClause {
+                            conditions: HashMap::new(),
+                            or_conditions: None,
+                            and: None,
+                            or: None,
+                        };
 
-                            where_clause.conditions.insert(
-                                "collection".to_string(),
-                                crate::models::WhereCondition {
-                gt: None,
-                gte: None,
-                lt: None,
-                lte: None,
-                                    eq: Some(serde_json::Value::String(nsid.clone())),
-                                    in_values: None,
-                                    contains: None,
-                                },
-                            );
+                        where_clause.conditions.insert(
+                            "collection".to_string(),
+                            crate::models::WhereCondition {
+                                gt: None,
+                                gte: None,
+                                lt: None,
+                                lte: None,
+                                eq: Some(serde_json::Value::String(nsid.clone())),
+                                in_values: None,
+                                contains: None,
+                                fuzzy: None,
+                            },
+                        );
 
-                            where_clause.conditions.insert(
-                                ref_field.clone(),
-                                crate::models::WhereCondition {
-                gt: None,
-                gte: None,
-                lt: None,
-                lte: None,
-                                    eq: Some(serde_json::Value::String(parent_uri.clone())),
-                                    in_values: None,
-                                    contains: None,
-                                },
-                            );
+                        where_clause.conditions.insert(
+                            ref_field.clone(),
+                            crate::models::WhereCondition {
+                                gt: None,
+                                gte: None,
+                                lt: None,
+                                lte: None,
+                                eq: Some(serde_json::Value::String(parent_uri.clone())),
+                                in_values: None,
+                                contains: None,
+                                fuzzy: None,
+                            },
+                        );
 
-                            match db.count_slice_collections_records(&slice, Some(&where_clause)).await {
-                                Ok(count) if count > 0 => {
-                                    return Ok(Some(FieldValue::value(count as i32)));
-                                }
-                                Ok(_) => continue,
-                                Err(e) => {
-                                    tracing::debug!("Count error for {}: {}", nsid, e);
-                                    continue;
-                                }
+                        match db
+                            .count_slice_collections_records(&slice, Some(&where_clause))
+                            .await
+                        {
+                            Ok(count) if count > 0 => {
+                                return Ok(Some(FieldValue::value(count as i32)));
+                            }
+                            Ok(_) => continue,
+                            Err(e) => {
+                                tracing::debug!("Count error for {}: {}", nsid, e);
+                                continue;
                             }
                         }
+                    }
 
-                        // No matching field found, return 0
-                        Ok(Some(FieldValue::value(0)))
-                    })
-                },
-            )
-        );
+                    // No matching field found, return 0
+                    Ok(Some(FieldValue::value(0)))
+                })
+            },
+        ));
     }
 
     object
···
             // 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 => {
+                GraphQLType::String
+                | GraphQLType::Int
+                | GraphQLType::Boolean
+                | GraphQLType::Float => {
                     let inner_ref = match inner.as_ref() {
                         GraphQLType::String => TypeRef::STRING,
                         GraphQLType::Int => TypeRef::INT,
···
     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())))
-        })
-    }));
+    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())))
-        })
-    }));
+    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| {
···
 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()));
+    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)
-        })
-    }));
+                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()));
+    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)
-        })
-    }));
+                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()));
+    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)
-        })
-    }));
+                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()));
+    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)
-        })
-    }));
+                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()));
+    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)
-        })
-    }));
+                Ok(None)
+            })
+        },
+    ));
 
     sync_result
 }
···
         .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)))
+        .field(InputValue::new("fuzzy", TypeRef::named(TypeRef::STRING)))
 }
 
 /// Creates the IntCondition input type for int field filtering
···
 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()));
+    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)))
-        })
-    }));
+                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()));
+    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)))
-        })
-    }));
+                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()));
+    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)
-        })
-    }));
+                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()));
+    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)
-        })
-    }));
+                Ok(None)
+            })
+        },
+    ));
 
     page_info
 }
···
     }));
 
     // 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 = 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
 }
···
     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)))
-        })
-    }));
+    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>()?;
+    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)
-            );
+                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());
+                // 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("startCursor"),
-                        GraphQLValue::from(start_cursor)
+                        async_graphql::Name::new("endCursor"),
+                        GraphQLValue::from(cursor.clone()),
                     );
                 }
-            }
 
-            // 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))))
-        })
-    }));
+                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>()?;
+    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();
+                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)))
-        })
-    }));
+                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>()?;
+    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();
+                let field_values: Vec<FieldValue<'_>> = data
+                    .nodes
+                    .iter()
+                    .map(|node| FieldValue::owned_any(node.clone()))
+                    .collect();
 
-            Ok(Some(FieldValue::list(field_values)))
-        })
-    }));
+                Ok(Some(FieldValue::list(field_values)))
+            })
+        },
+    ));
 
     connection
 }
···
                 let slice = slice_clone.clone();
 
                 FieldFuture::new(async move {
-                    let did = ctx.args.get("did")
+                    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)))?;
+                        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(),
···
 
                     // 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));
+                    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))))
                 })
···
             "did",
             TypeRef::named_nn(TypeRef::STRING),
         ))
-        .description("Sync user collections for a given DID")
+        .description("Sync user collections for a given DID"),
     );
 
     mutation
···
     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") {
+    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();
···
     for field in fields {
         let field_name = field.name.clone();
         let field_name_clone = field_name.clone();
-        aggregated = aggregated.field(Field::new(&field_name, TypeRef::named("JSON"), move |ctx| {
-            let field_name = field_name_clone.clone();
+        aggregated = aggregated.field(Field::new(
+            &field_name,
+            TypeRef::named("JSON"),
+            move |ctx| {
+                let field_name = field_name_clone.clone();
+                FieldFuture::new(async move {
+                    let json_value = ctx.parent_value.try_downcast_ref::<serde_json::Value>()?;
+                    if let Some(obj) = json_value.as_object() {
+                        if let Some(value) = obj.get(&field_name) {
+                            // Convert serde_json::Value to async_graphql::Value
+                            let graphql_value = serde_json_to_graphql_value(value);
+                            return Ok(Some(graphql_value));
+                        }
+                    }
+                    Ok(None)
+                })
+            },
+        ));
+    }
+
+    // Add count field
+    aggregated = aggregated.field(Field::new(
+        "count",
+        TypeRef::named_nn(TypeRef::INT),
+        |ctx| {
             FieldFuture::new(async move {
                 let json_value = ctx.parent_value.try_downcast_ref::<serde_json::Value>()?;
                 if let Some(obj) = json_value.as_object() {
-                    if let Some(value) = obj.get(&field_name) {
-                        // Convert serde_json::Value to async_graphql::Value
-                        let graphql_value = serde_json_to_graphql_value(value);
-                        return Ok(Some(graphql_value));
+                    if let Some(count) = obj.get("count") {
+                        if let Some(count_i64) = count.as_i64() {
+                            return Ok(Some(GraphQLValue::from(count_i64 as i32)));
+                        }
                     }
                 }
-                Ok(None)
+                Ok(Some(GraphQLValue::from(0)))
             })
-        }));
-    }
-
-    // Add count field
-    aggregated = aggregated.field(Field::new("count", TypeRef::named_nn(TypeRef::INT), |ctx| {
-        FieldFuture::new(async move {
-            let json_value = ctx.parent_value.try_downcast_ref::<serde_json::Value>()?;
-            if let Some(obj) = json_value.as_object() {
-                if let Some(count) = obj.get("count") {
-                    if let Some(count_i64) = count.as_i64() {
-                        return Ok(Some(GraphQLValue::from(count_i64 as i32)));
-                    }
-                }
-            }
-            Ok(Some(GraphQLValue::from(0)))
-        })
-    }));
+        },
+    ));
 
     aggregated
 }
···
 fn create_record_update_type() -> Object {
     let mut record_update = Object::new("RecordUpdate");
 
-    record_update = record_update.field(Field::new("uri", 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 RecordUpdate"))?;
-            if let GraphQLValue::Object(obj) = value {
-                if let Some(uri) = obj.get("uri") {
-                    return Ok(Some(uri.clone()));
+    record_update = record_update.field(Field::new(
+        "uri",
+        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 RecordUpdate"))?;
+                if let GraphQLValue::Object(obj) = value {
+                    if let Some(uri) = obj.get("uri") {
+                        return Ok(Some(uri.clone()));
+                    }
                 }
-            }
-            Ok(None)
-        })
-    }));
+                Ok(None)
+            })
+        },
+    ));
 
-    record_update = record_update.field(Field::new("cid", 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 RecordUpdate"))?;
-            if let GraphQLValue::Object(obj) = value {
-                if let Some(cid) = obj.get("cid") {
-                    return Ok(Some(cid.clone()));
+    record_update = record_update.field(Field::new(
+        "cid",
+        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 RecordUpdate"))?;
+                if let GraphQLValue::Object(obj) = value {
+                    if let Some(cid) = obj.get("cid") {
+                        return Ok(Some(cid.clone()));
+                    }
                 }
-            }
-            Ok(None)
-        })
-    }));
+                Ok(None)
+            })
+        },
+    ));
 
-    record_update = record_update.field(Field::new("did", 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 RecordUpdate"))?;
-            if let GraphQLValue::Object(obj) = value {
-                if let Some(did) = obj.get("did") {
-                    return Ok(Some(did.clone()));
+    record_update = record_update.field(Field::new(
+        "did",
+        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 RecordUpdate"))?;
+                if let GraphQLValue::Object(obj) = value {
+                    if let Some(did) = obj.get("did") {
+                        return Ok(Some(did.clone()));
+                    }
                 }
-            }
-            Ok(None)
-        })
-    }));
+                Ok(None)
+            })
+        },
+    ));
 
-    record_update = record_update.field(Field::new("collection", 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 RecordUpdate"))?;
-            if let GraphQLValue::Object(obj) = value {
-                if let Some(collection) = obj.get("collection") {
-                    return Ok(Some(collection.clone()));
+    record_update = record_update.field(Field::new(
+        "collection",
+        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 RecordUpdate"))?;
+                if let GraphQLValue::Object(obj) = value {
+                    if let Some(collection) = obj.get("collection") {
+                        return Ok(Some(collection.clone()));
+                    }
                 }
-            }
-            Ok(None)
-        })
-    }));
+                Ok(None)
+            })
+        },
+    ));
 
-    record_update = record_update.field(Field::new("indexedAt", 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 RecordUpdate"))?;
-            if let GraphQLValue::Object(obj) = value {
-                if let Some(indexed_at) = obj.get("indexedAt") {
-                    return Ok(Some(indexed_at.clone()));
+    record_update = record_update.field(Field::new(
+        "indexedAt",
+        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 RecordUpdate"))?;
+                if let GraphQLValue::Object(obj) = value {
+                    if let Some(indexed_at) = obj.get("indexedAt") {
+                        return Ok(Some(indexed_at.clone()));
+                    }
                 }
-            }
-            Ok(None)
-        })
-    }));
+                Ok(None)
+            })
+        },
+    ));
 
-    record_update = record_update.field(Field::new("operation", 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 RecordUpdate"))?;
-            if let GraphQLValue::Object(obj) = value {
-                if let Some(operation) = obj.get("operation") {
-                    return Ok(Some(operation.clone()));
+    record_update = record_update.field(Field::new(
+        "operation",
+        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 RecordUpdate"))?;
+                if let GraphQLValue::Object(obj) = value {
+                    if let Some(operation) = obj.get("operation") {
+                        return Ok(Some(operation.clone()));
+                    }
                 }
-            }
-            Ok(None)
-        })
-    }));
+                Ok(None)
+            })
+        },
+    ));
 
     record_update = record_update.field(Field::new("value", TypeRef::named_nn("JSON"), |ctx| {
         FieldFuture::new(async move {
-            let value = ctx.parent_value.downcast_ref::<GraphQLValue>()
+            let value = ctx
+                .parent_value
+                .downcast_ref::<GraphQLValue>()
                 .ok_or_else(|| Error::new("Failed to downcast RecordUpdate"))?;
             if let GraphQLValue::Object(obj) = value {
                 if let Some(val) = obj.get("value") {
···
 }
 
 /// Helper function to parse GraphQL where clause recursively
-fn parse_where_clause(where_obj: async_graphql::dynamic::ObjectAccessor) -> crate::models::WhereClause {
+fn parse_where_clause(
+    where_obj: async_graphql::dynamic::ObjectAccessor,
+) -> crate::models::WhereClause {
     let mut where_clause = crate::models::WhereClause {
         conditions: HashMap::new(),
         or_conditions: None,
···
                 eq: None,
                 in_values: None,
                 contains: None,
+                fuzzy: None,
                 gt: None,
                 gte: None,
                 lt: None,
···
                 }
             }
 
+            // Parse fuzzy condition
+            if let Some(fuzzy_val) = condition_obj.get("fuzzy") {
+                if let Ok(fuzzy_str) = fuzzy_val.string() {
+                    where_condition.fuzzy = Some(fuzzy_str.to_string());
+                }
+            }
+
             // Parse gt condition
             if let Some(gt_val) = condition_obj.get("gt") {
                 if let Ok(gt_str) = gt_val.string() {
···
                 field_str.to_string()
             };
 
-            where_clause.conditions.insert(db_field_name, where_condition);
+            where_clause
+                .conditions
+                .insert(db_field_name, where_condition);
         }
     }
 

api/src/graphql/types.rs

···
 }
 
 /// Maps AT Protocol lexicon type to GraphQL type
-pub fn map_lexicon_type_to_graphql(
-    type_name: &str,
-    lexicon_def: &Value,
-) -> GraphQLType {
+pub fn map_lexicon_type_to_graphql(type_name: &str, lexicon_def: &Value) -> GraphQLType {
     match type_name {
         "string" => GraphQLType::String,
         "integer" => GraphQLType::Int,
···
             GraphQLType::Array(Box::new(item_type))
         }
         "object" => {
-            let properties = lexicon_def
-                .get("properties")
-                .and_then(|p| p.as_object());
+            let properties = lexicon_def.get("properties").and_then(|p| p.as_object());
 
             let required_fields: Vec<String> = lexicon_def
                 .get("required")
···
                         GraphQLField {
                             name: field_name.clone(),
                             format,
-                            field_type: map_lexicon_type_to_graphql(
-                                field_type_name,
-                                field_def,
-                            ),
+                            field_type: map_lexicon_type_to_graphql(field_type_name, field_def),
                             is_required: required_fields.contains(&field_name.to_string()),
                         }
                     })
···
                 GraphQLType::Json
             }
         }
-        "union" => {
-            GraphQLType::Union
-        }
+        "union" => GraphQLType::Union,
         _ => GraphQLType::Json,
     }
 }
 
 /// Extract collection schema from lexicon definitions
-pub fn extract_collection_fields(
-    lexicon_defs: &Value,
-) -> Vec<GraphQLField> {
+pub fn extract_collection_fields(lexicon_defs: &Value) -> Vec<GraphQLField> {
     let main_def = lexicon_defs
         .get("main")
         .or_else(|| lexicon_defs.get("record"));
···
                 .and_then(|t| t.as_str())
                 .unwrap_or("object");
 
-            if let GraphQLType::Object(fields) = map_lexicon_type_to_graphql(object_type_name, object_def) {
+            if let GraphQLType::Object(fields) =
+                map_lexicon_type_to_graphql(object_type_name, object_def)
+            {
                 return fields;
             }
         }

api/src/jetstream.rs

···
 use crate::cache::{CacheBackend, CacheFactory, SliceCache};
 use crate::database::Database;
 use crate::errors::JetstreamError;
-use crate::graphql::{RecordOperation, RecordUpdateEvent, PUBSUB};
+use crate::graphql::{PUBSUB, RecordOperation, RecordUpdateEvent};
 use crate::jetstream_cursor::PostgresCursorHandler;
 use crate::logging::{LogLevel, Logger};
 use crate::models::{Actor, Record};
···
 
                 // Check if this is a primary collection (starts with slice domain)
                 // Lexicon records for this slice are always treated as primary
-                let is_primary_collection = commit.collection.starts_with(&domain) || is_lexicon_for_this_slice;
+                let is_primary_collection =
+                    commit.collection.starts_with(&domain) || is_lexicon_for_this_slice;
 
                 // For external collections, check actor status BEFORE expensive validation
                 if !is_primary_collection {
···
                                     };
 
                                     // Insert into database
-                                    if let Err(e) = self.database.batch_insert_actors(&[actor]).await {
+                                    if let Err(e) =
+                                        self.database.batch_insert_actors(&[actor]).await
+                                    {
                                         error!("Failed to create actor {}: {}", did, e);
                                     } else {
                                         // Add to cache after successful database insert

api/src/main.rs

···
                             e,
                             retry_delay
                         );
-                        jetstream_connected_clone.store(false, std::sync::atomic::Ordering::Relaxed);
+                        jetstream_connected_clone
+                            .store(false, std::sync::atomic::Ordering::Relaxed);
                         tokio::time::sleep(retry_delay).await;
                         retry_delay = std::cmp::min(retry_delay * 2, MAX_RETRY_DELAY);
                         continue;
···
                 match consumer_arc.start_consuming(cancellation_token).await {
                     Ok(_) => {
                         tracing::info!("Jetstream consumer shut down normally");
-                        jetstream_connected_clone.store(false, std::sync::atomic::Ordering::Relaxed);
+                        jetstream_connected_clone
+                            .store(false, std::sync::atomic::Ordering::Relaxed);
                     }
                     Err(e) => {
                         tracing::error!("Jetstream consumer failed: {} - will reconnect", e);
-                        jetstream_connected_clone.store(false, std::sync::atomic::Ordering::Relaxed);
+                        jetstream_connected_clone
+                            .store(false, std::sync::atomic::Ordering::Relaxed);
                         tokio::time::sleep(retry_delay).await;
                         retry_delay = std::cmp::min(retry_delay * 2, MAX_RETRY_DELAY);
                     }
···
             "/graphql",
             get(graphql::graphql_playground).post(graphql::graphql_handler),
         )
-        .route(
-            "/graphql/ws",
-            get(graphql::graphql_subscription_handler),
-        )
+        .route("/graphql/ws", get(graphql::graphql_subscription_handler))
         // Dynamic collection-specific XRPC endpoints (wildcard routes must come last)
         .route(
             "/xrpc/{*method}",

api/src/sync.rs

···
             // First, get all repos from primary collections
             let mut primary_repos = std::collections::HashSet::new();
             for collection in &primary_collections {
-                match self.get_repos_for_collection(collection, slice_uri, max_repos).await {
+                match self
+                    .get_repos_for_collection(collection, slice_uri, max_repos)
+                    .await
+                {
                     Ok(repos) => {
                         info!(
                             "Found {} repositories for primary collection \"{}\"",
···
                 match database.batch_insert_records(&batch).await {
                     Ok(_) => {
                         write_count += batch_size;
-                        info!("Database writer: Inserted batch of {} records (total: {})", batch_size, write_count);
+                        info!(
+                            "Database writer: Inserted batch of {} records (total: {})",
+                            batch_size, write_count
+                        );
                     }
                     Err(e) => {
                         error!("Database writer: Failed to insert batch: {}", e);
···
 
             // Send batch to writer when buffer is full
             if batch_buffer.len() >= BATCH_SIZE {
-                let batch_to_send = std::mem::replace(&mut batch_buffer, Vec::with_capacity(BATCH_SIZE));
+                let batch_to_send =
+                    std::mem::replace(&mut batch_buffer, Vec::with_capacity(BATCH_SIZE));
                 let batch_count = batch_to_send.len() as i64;
-                info!("Sending batch of {} records to database writer", batch_count);
+                info!(
+                    "Sending batch of {} records to database writer",
+                    batch_count
+                );
 
                 // Send to writer channel (non-blocking)
                 if let Err(e) = tx.send(batch_to_send).await {
                     error!("Failed to send batch to writer: {}", e);
-                    return Err(SyncError::Generic(format!("Failed to send batch to writer: {}", e)));
+                    return Err(SyncError::Generic(format!(
+                        "Failed to send batch to writer: {}",
+                        e
+                    )));
                 }
 
                 let mut total = total_indexed_records.lock().await;
···
         // Flush any remaining records in the buffer
         if !batch_buffer.is_empty() {
             let batch_count = batch_buffer.len() as i64;
-            info!("Sending final batch of {} records to database writer", batch_count);
+            info!(
+                "Sending final batch of {} records to database writer",
+                batch_count
+            );
 
             if let Err(e) = tx.send(batch_buffer).await {
                 error!("Failed to send final batch to writer: {}", e);
-                return Err(SyncError::Generic(format!("Failed to send final batch to writer: {}", e)));
+                return Err(SyncError::Generic(format!(
+                    "Failed to send final batch to writer: {}",
+                    e
+                )));
             }
 
             let mut total = total_indexed_records.lock().await;
···
 
         // Close the channel and wait for writer to finish
         drop(tx);
-        let write_result = writer_task.await
+        let write_result = writer_task
+            .await
             .map_err(|e| SyncError::Generic(format!("Writer task panicked: {}", e)))?;
 
         let final_count = match write_result {
···
             successful_tasks, failed_tasks
         );
 
-        info!(
-            "Indexed {} new/changed records in batches",
-            final_count
-        );
+        info!("Indexed {} new/changed records in batches", final_count);
 
         info!("Backfill complete!");
 
···
             if page_count > max_pages {
                 warn!(
                     "Reached maximum page limit ({}) for collection {} (based on repo limit {:?}, estimated max {} repos at {} per page)",
-                    max_pages, collection, max_repos, max_pages * REPOS_PER_PAGE, REPOS_PER_PAGE
+                    max_pages,
+                    collection,
+                    max_repos,
+                    max_pages * REPOS_PER_PAGE,
+                    REPOS_PER_PAGE
                 );
                 break;
             }
···
         const CHUNK_SIZE: usize = 50; // Process DIDs in chunks
         const MAX_CONCURRENT: usize = 10; // Limit concurrent resolutions
 
-        info!("Resolving ATP data for {} repositories in chunks", repos.len());
+        info!(
+            "Resolving ATP data for {} repositories in chunks",
+            repos.len()
+        );
 
         for (chunk_idx, chunk) in repos.chunks(CHUNK_SIZE).enumerate() {
             let chunk_start = chunk_idx * CHUNK_SIZE;
···
             }
         }
 
-        info!("Successfully resolved ATP data for {}/{} repositories", atp_map.len(), repos.len());
+        info!(
+            "Successfully resolved ATP data for {}/{} repositories",
+            atp_map.len(),
+            repos.len()
+        );
         Ok(atp_map)
     }
 
···
                 Some(&external_collections),
                 Some(&[user_did.to_string()]), // Only sync this user's repos
                 false,                         // Always validate user collections
-                None,  // No limit for user-specific sync
+                None,                          // No limit for user-specific sync
             )
             .await
         };

api/src/xrpc/network/slices/slice/clear_slice_records.rs

···
-use crate::{auth, errors::AppError, AppState};
+use crate::{AppState, auth, errors::AppError};
 use axum::{extract::State, http::HeaderMap, response::Json};
 use serde::{Deserialize, Serialize};
 
···
             records_deleted, actors_deleted
         ),
     }))
-}
+}

api/src/xrpc/network/slices/slice/get_actors.rs

···
-use crate::{
-    AppState,
-    database::types::WhereClause,
-    errors::AppError,
-    models::Actor,
-};
+use crate::{AppState, database::types::WhereClause, errors::AppError, models::Actor};
 use axum::{extract::State, response::Json};
 use serde::{Deserialize, Serialize};
 

api/src/xrpc/network/slices/slice/get_sync_summary.rs

···
 use crate::{AppState, auth, errors::AppError, sync::SyncService};
-use axum::{extract::{Query, State}, http::HeaderMap, response::Json};
+use axum::{
+    extract::{Query, State},
+    http::HeaderMap,
+    response::Json,
+};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
···
 
         // First, get repos ONLY from primary collections
         for collection in &primary_collections {
-            match sync_service.get_repos_for_collection(collection, slice_uri, Some(applied_limit)).await {
+            match sync_service
+                .get_repos_for_collection(collection, slice_uri, Some(applied_limit))
+                .await
+            {
                 Ok(repos) => {
                     counts.insert(collection.clone(), repos.len() as i64);
                     discovered_repos.extend(repos);

docs/graphql-api.md

···
 - `eq`: Exact match
 - `in`: Match any value in array
 - `contains`: Substring match (case-insensitive)
+- `fuzzy`: Fuzzy/similarity match (typo-tolerant)
 - `gt`: Greater than (lexicographic)
 - `gte`: Greater than or equal to
 - `lt`: Less than
···
 - `gte`: At or after datetime
 - `lt`: Before datetime
 - `lte`: At or before datetime
+
+#### Fuzzy Matching Example
+
+The `fuzzy` filter uses PostgreSQL's trigram similarity for typo-tolerant search:
+
+```graphql
+query FuzzySearch {
+  fmTealAlphaFeedPlays(
+    where: {
+      trackName: { fuzzy: "love" }
+    }
+  ) {
+    edges {
+      node {
+        trackName
+        artists
+      }
+    }
+  }
+}
+```
+
+This will match track names like:
+- "Love" (exact)
+- "Love Song"
+- "Lovely"
+- "I Love You"
+- "Lover"
+- "Loveless"
+
+The fuzzy filter is great for:
+- Handling typos and misspellings
+- Finding similar variations of text
+- Flexible search without exact matching
+
+**Note**: Fuzzy matching works on the similarity between strings (using trigrams), so it's more flexible than `contains` but may return unexpected matches if the similarity threshold is met.
 
 #### Date Range Example