value query dsl

crates/jacquard-common/src/types/value.rs

···
         serde_ipld_dagcbor::to_vec(self)
     }
 
+    /// Get a value at a path within nested Data structures
+    ///
+    /// Path syntax:
+    /// - `.field` or `field` - access object field
+    /// - `[0]` - access array index
+    /// - Combined: `embed.images[0].alt`
+    ///
+    /// # Example
+    /// ```ignore
+    /// let data: Data = ...;
+    /// if let Some(alt_text) = data.get_at_path("embed.images[0].alt") {
+    ///     println!("Alt text: {}", alt_text.as_str().unwrap());
+    /// }
+    /// ```
+    pub fn get_at_path(&'s self, path: &str) -> Option<&'s Data<'s>> {
+        parse_and_traverse_path(self, path)
+    }
+
+    /// Query data with pattern matching
+    ///
+    /// Pattern syntax:
+    /// - `field.nested` - exact path navigation
+    /// - `[..]` - wildcard over collection (array elements or object values)
+    /// - `field..nested` - scoped recursion (find nested within field, expect one)
+    /// - `...field` - global recursion (find all occurrences anywhere)
+    ///
+    /// # Examples
+    /// ```ignore
+    /// // Exact path with wildcard
+    /// let alts = data.query("embed.[..].alt");
+    ///
+    /// // Scoped recursion
+    /// let handle = data.query("post..handle"); // finds post.author.handle
+    ///
+    /// // Global recursion
+    /// let all_cids = data.query("...cid"); // all CIDs anywhere
+    /// ```
+    pub fn query(&'s self, pattern: &str) -> QueryResult<'s> {
+        query_data(self, pattern)
+    }
+
     /// Parse a Data value from an IPLD value (CBOR)
     pub fn from_cbor(cbor: &'s Ipld) -> Result<Self, AtDataError> {
         Ok(match cbor {
···
 }
 
 impl<'s> Array<'s> {
+    /// Get the number of elements in the array
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    /// Check if the array is empty
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
+    /// Get an element by index
+    pub fn get(&self, index: usize) -> Option<&Data<'s>> {
+        self.0.get(index)
+    }
+
+    /// Get an iterator over the array elements
+    pub fn iter(&self) -> std::slice::Iter<'_, Data<'s>> {
+        self.0.iter()
+    }
+
     /// Parse an array from JSON values
     pub fn from_json(json: &'s Vec<serde_json::Value>) -> Result<Self, AtDataError> {
         let mut array = Vec::with_capacity(json.len());
···
     }
 }
 
+impl<'s> std::ops::Index<usize> for Array<'s> {
+    type Output = Data<'s>;
+
+    fn index(&self, index: usize) -> &Self::Output {
+        &self.0[index]
+    }
+}
+
 /// Object/map of AT Protocol data values
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Object<'s>(pub BTreeMap<SmolStr, Data<'s>>);
···
 }
 
 impl<'s> Object<'s> {
+    /// Get a value by key
+    pub fn get(&self, key: &str) -> Option<&Data<'s>> {
+        self.0.get(key)
+    }
+
+    /// Check if a key exists in the object
+    pub fn contains_key(&self, key: &str) -> bool {
+        self.0.contains_key(key)
+    }
+
+    /// Get the number of key-value pairs in the object
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    /// Check if the object is empty
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
+    /// Get an iterator over the key-value pairs
+    pub fn iter(&self) -> std::collections::btree_map::Iter<'_, SmolStr, Data<'s>> {
+        self.0.iter()
+    }
+
+    /// Get an iterator over the keys
+    pub fn keys(&self) -> std::collections::btree_map::Keys<'_, SmolStr, Data<'s>> {
+        self.0.keys()
+    }
+
+    /// Get an iterator over the values
+    pub fn values(&self) -> std::collections::btree_map::Values<'_, SmolStr, Data<'s>> {
+        self.0.values()
+    }
+
     /// Parse an object from a JSON map with type inference
     ///
     /// Uses key names to infer the appropriate AT Protocol types for values.
···
     }
 }
 
+impl<'s> std::ops::Index<&str> for Object<'s> {
+    type Output = Data<'s>;
+
+    fn index(&self, key: &str) -> &Self::Output {
+        &self.0[key]
+    }
+}
+
 /// Level 1 deserialization of raw atproto data
 ///
 /// Maximally permissive with zero inference for cases where you just want to pass through the data
···
         serde_ipld_dagcbor::to_vec(self)
     }
 
+    /// Get a value at a path within nested RawData structures
+    ///
+    /// Path syntax:
+    /// - `.field` or `field` - access object field
+    /// - `[0]` - access array index
+    /// - Combined: `embed.images[0].alt`
+    ///
+    /// # Example
+    /// ```ignore
+    /// let data: RawData = ...;
+    /// if let Some(alt_text) = data.get_at_path("embed.images[0].alt") {
+    ///     println!("Alt text: {}", alt_text.as_str().unwrap());
+    /// }
+    /// ```
+    pub fn get_at_path(&'d self, path: &str) -> Option<&'d RawData<'d>> {
+        parse_and_traverse_raw_path(self, path)
+    }
+
     /// Convert a CBOR-encoded byte slice into a `RawData` value.
     /// Parse a Data value from an IPLD value (CBOR)
     pub fn from_cbor(cbor: &'d Ipld) -> Result<Self, AtDataError> {
···
     })?;
     raw.try_into()
 }
+
+/// Parse and traverse a path through nested Data structures
+fn parse_and_traverse_path<'s>(data: &'s Data<'s>, path: &str) -> Option<&'s Data<'s>> {
+    let mut current = data;
+    let mut path = path.trim_start_matches('.');
+
+    while !path.is_empty() {
+        if path.starts_with('[') {
+            // Array index: [N]
+            let idx_end = path.find(']')?;
+            let idx_str = &path[1..idx_end];
+            let idx: usize = idx_str.parse().ok()?;
+
+            current = current.as_array()?.get(idx)?;
+            path = &path[idx_end + 1..].trim_start_matches('.');
+        } else {
+            // Field access: extract next segment (up to '.' or '[')
+            let next_sep = path.find(&['.', '['][..]).unwrap_or(path.len());
+            let field = &path[..next_sep];
+
+            if field.is_empty() {
+                break;
+            }
+
+            current = current.as_object()?.get(field)?;
+            path = &path[next_sep..].trim_start_matches('.');
+        }
+    }
+
+    Some(current)
+}
+
+/// Parse and traverse a path through nested RawData structures
+fn parse_and_traverse_raw_path<'d>(data: &'d RawData<'d>, path: &str) -> Option<&'d RawData<'d>> {
+    let mut current = data;
+    let mut path = path.trim_start_matches('.');
+
+    while !path.is_empty() {
+        if path.starts_with('[') {
+            // Array index: [N]
+            let idx_end = path.find(']')?;
+            let idx_str = &path[1..idx_end];
+            let idx: usize = idx_str.parse().ok()?;
+
+            current = current.as_array()?.get(idx)?;
+            path = &path[idx_end + 1..].trim_start_matches('.');
+        } else {
+            // Field access: extract next segment (up to '.' or '[')
+            let next_sep = path.find(&['.', '['][..]).unwrap_or(path.len());
+            let field = &path[..next_sep];
+
+            if field.is_empty() {
+                break;
+            }
+
+            current = current.as_object()?.get(field as &str)?;
+            path = &path[next_sep..].trim_start_matches('.');
+        }
+    }
+
+    Some(current)
+}
+
+/// Result of a data query operation
+#[derive(Debug, Clone, PartialEq)]
+pub enum QueryResult<'s> {
+    /// Single value expected and found
+    Single(&'s Data<'s>),
+
+    /// Multiple values from wildcard or global recursion
+    Multiple(Vec<QueryMatch<'s>>),
+
+    /// No matches found
+    None,
+}
+
+impl<'s> QueryResult<'s> {
+    /// Get single value if available
+    pub fn single(&self) -> Option<&'s Data<'s>> {
+        match self {
+            QueryResult::Single(data) => Some(data),
+            _ => None,
+        }
+    }
+
+    /// Get multiple matches if available
+    pub fn multiple(&self) -> Option<&[QueryMatch<'s>]> {
+        match self {
+            QueryResult::Multiple(matches) => Some(matches),
+            _ => None,
+        }
+    }
+
+    /// Get first value regardless of result type
+    pub fn first(&self) -> Option<&'s Data<'s>> {
+        match self {
+            QueryResult::Single(data) => Some(data),
+            QueryResult::Multiple(matches) => matches.first().and_then(|m| m.value),
+            QueryResult::None => None,
+        }
+    }
+
+    /// Check if any results were found
+    pub fn is_empty(&self) -> bool {
+        matches!(self, QueryResult::None)
+    }
+
+    /// Get all values as an iterator (flattens single/multiple)
+    pub fn values(&self) -> impl Iterator<Item = &'s Data<'s>> {
+        match self {
+            QueryResult::Single(data) => vec![*data].into_iter(),
+            QueryResult::Multiple(matches) => matches
+                .iter()
+                .filter_map(|m| m.value)
+                .collect::<Vec<_>>()
+                .into_iter(),
+            QueryResult::None => vec![].into_iter(),
+        }
+    }
+}
+
+/// A single match from a query operation
+#[derive(Debug, Clone, PartialEq)]
+pub struct QueryMatch<'s> {
+    /// Path where this value was found (e.g., "actors[0].handle")
+    pub path: SmolStr,
+    /// The value (None if field was missing during wildcard iteration)
+    pub value: Option<&'s Data<'s>>,
+}
+
+/// Query pattern segment
+#[derive(Debug, Clone, PartialEq)]
+enum QuerySegment {
+    /// Exact field name
+    Field(SmolStr),
+    /// Wildcard [..]
+    Wildcard,
+    /// Scoped recursion ..field
+    ScopedRecursion(SmolStr),
+    /// Global recursion ...field
+    GlobalRecursion(SmolStr),
+}
+
+/// Parse a query pattern into segments
+fn parse_query_pattern(pattern: &str) -> Vec<QuerySegment> {
+    let mut segments = Vec::new();
+    let mut remaining = pattern;
+
+    // Skip single leading dot if present
+    if remaining.starts_with('.') && !remaining.starts_with("..") {
+        remaining = &remaining[1..];
+    }
+
+    while !remaining.is_empty() {
+        if remaining.starts_with("...") {
+            // Global recursion
+            let rest = &remaining[3..];
+            let end = rest.find(&['.', '['][..]).unwrap_or(rest.len());
+            let field = SmolStr::new(&rest[..end]);
+            segments.push(QuerySegment::GlobalRecursion(field));
+            remaining = &rest[end..];
+            // Skip single dot separator
+            if remaining.starts_with('.') && !remaining.starts_with("..") {
+                remaining = &remaining[1..];
+            }
+        } else if remaining.starts_with("..") {
+            // Scoped recursion
+            let rest = &remaining[2..];
+            let end = rest.find(&['.', '['][..]).unwrap_or(rest.len());
+            let field = SmolStr::new(&rest[..end]);
+            segments.push(QuerySegment::ScopedRecursion(field));
+            remaining = &rest[end..];
+            // Skip single dot separator
+            if remaining.starts_with('.') && !remaining.starts_with("..") {
+                remaining = &remaining[1..];
+            }
+        } else if remaining.starts_with("[..]") {
+            // Wildcard
+            segments.push(QuerySegment::Wildcard);
+            remaining = &remaining[4..];
+            // Skip single dot separator
+            if remaining.starts_with('.') && !remaining.starts_with("..") {
+                remaining = &remaining[1..];
+            }
+        } else {
+            // Regular field
+            let end = remaining.find(&['.', '['][..]).unwrap_or(remaining.len());
+            let field = &remaining[..end];
+            if !field.is_empty() {
+                segments.push(QuerySegment::Field(SmolStr::new(field)));
+            }
+            remaining = &remaining[end..];
+            // Skip single dot separator
+            if remaining.starts_with('.') && !remaining.starts_with("..") {
+                remaining = &remaining[1..];
+            }
+        }
+    }
+
+    segments
+}
+
+/// Execute a query on data
+fn query_data<'s>(data: &'s Data<'s>, pattern: &str) -> QueryResult<'s> {
+    let segments = parse_query_pattern(pattern);
+    if segments.is_empty() {
+        return QueryResult::None;
+    }
+
+    let mut results = vec![QueryMatch {
+        path: SmolStr::new_static(""),
+        value: Some(data),
+    }];
+
+    // Determine result type based on segment types before consuming segments
+    let has_wildcard = segments.iter().any(|s| matches!(s, QuerySegment::Wildcard));
+    let has_global = segments.iter().any(|s| matches!(s, QuerySegment::GlobalRecursion(_)));
+
+    for segment in segments {
+        results = execute_segment(&results, &segment);
+        if results.is_empty() {
+            return QueryResult::None;
+        }
+    }
+
+    if has_wildcard || has_global || results.len() > 1 {
+        QueryResult::Multiple(results)
+    } else if results.len() == 1 {
+        if let Some(value) = results[0].value {
+            QueryResult::Single(value)
+        } else {
+            QueryResult::None
+        }
+    } else {
+        QueryResult::None
+    }
+}
+
+/// Execute a single segment on current results
+fn execute_segment<'s>(current: &[QueryMatch<'s>], segment: &QuerySegment) -> Vec<QueryMatch<'s>> {
+    let mut next = Vec::new();
+
+    for qm in current {
+        let Some(data) = qm.value else { continue };
+
+        match segment {
+            QuerySegment::Field(field) => {
+                if let Some(obj) = data.as_object() {
+                    if let Some(value) = obj.get(field.as_str()) {
+                        let new_path = append_path(&qm.path, field.as_str());
+                        next.push(QueryMatch {
+                            path: new_path,
+                            value: Some(value),
+                        });
+                    }
+                }
+            }
+
+            QuerySegment::Wildcard => match data {
+                Data::Array(arr) => {
+                    for (idx, item) in arr.iter().enumerate() {
+                        let new_path = append_path(&qm.path, &format!("[{}]", idx));
+                        next.push(QueryMatch {
+                            path: new_path,
+                            value: Some(item),
+                        });
+                    }
+                }
+                Data::Object(obj) => {
+                    for (key, value) in obj.iter() {
+                        let new_path = append_path(&qm.path, key.as_str());
+                        next.push(QueryMatch {
+                            path: new_path,
+                            value: Some(value),
+                        });
+                    }
+                }
+                _ => {}
+            },
+
+            QuerySegment::ScopedRecursion(field) => {
+                if let Some(found) = find_field_recursive(data, field.as_str(), &qm.path) {
+                    next.push(found);
+                }
+            }
+
+            QuerySegment::GlobalRecursion(field) => {
+                find_all_fields_recursive(data, field.as_str(), &qm.path, &mut next);
+            }
+        }
+    }
+
+    next
+}
+
+/// Recursively find first occurrence of a field (scoped recursion)
+fn find_field_recursive<'s>(
+    data: &'s Data<'s>,
+    field: &str,
+    base_path: &SmolStr,
+) -> Option<QueryMatch<'s>> {
+    match data {
+        Data::Object(obj) => {
+            // Check direct children first
+            if let Some(value) = obj.get(field) {
+                let new_path = append_path(base_path, field);
+                return Some(QueryMatch {
+                    path: new_path,
+                    value: Some(value),
+                });
+            }
+
+            // Recurse into nested objects
+            for (key, value) in obj.iter() {
+                let new_path = append_path(base_path, key.as_str());
+                if let Some(found) = find_field_recursive(value, field, &new_path) {
+                    return Some(found);
+                }
+            }
+        }
+        Data::Array(arr) => {
+            for (idx, item) in arr.iter().enumerate() {
+                let new_path = append_path(base_path, &format!("[{}]", idx));
+                if let Some(found) = find_field_recursive(item, field, &new_path) {
+                    return Some(found);
+                }
+            }
+        }
+        _ => {}
+    }
+
+    None
+}
+
+/// Recursively find all occurrences of a field (global recursion)
+fn find_all_fields_recursive<'s>(
+    data: &'s Data<'s>,
+    field: &str,
+    base_path: &SmolStr,
+    results: &mut Vec<QueryMatch<'s>>,
+) {
+    match data {
+        Data::Object(obj) => {
+            // Check direct children
+            if let Some(value) = obj.get(field) {
+                let new_path = append_path(base_path, field);
+                results.push(QueryMatch {
+                    path: new_path,
+                    value: Some(value),
+                });
+            }
+
+            // Recurse into all nested values
+            for (key, value) in obj.iter() {
+                let new_path = append_path(base_path, key.as_str());
+                find_all_fields_recursive(value, field, &new_path, results);
+            }
+        }
+        Data::Array(arr) => {
+            for (idx, item) in arr.iter().enumerate() {
+                let new_path = append_path(base_path, &format!("[{}]", idx));
+                find_all_fields_recursive(item, field, &new_path, results);
+            }
+        }
+        _ => {}
+    }
+}
+
+/// Append a segment to a path
+fn append_path(base: &SmolStr, segment: &str) -> SmolStr {
+    if base.is_empty() {
+        SmolStr::new(segment)
+    } else if segment.starts_with('[') {
+        SmolStr::new(format!("{}{}", base, segment))
+    } else {
+        SmolStr::new(format!("{}.{}", base, segment))
+    }
+}

crates/jacquard-common/src/types/value/tests.rs

···
     assert!(cbor_result.is_ok());
     assert!(!cbor_result.unwrap().is_empty());
 }
+
+#[test]
+fn test_object_methods() {
+    let mut map = BTreeMap::new();
+    map.insert(SmolStr::new_static("num"), Data::Integer(42));
+    map.insert(SmolStr::new_static("text"), Data::String(AtprotoStr::String("hello".into())));
+    let obj = Object(map);
+
+    // Test get
+    assert!(obj.get("num").is_some());
+    assert_eq!(obj.get("num"), Some(&Data::Integer(42)));
+    assert!(obj.get("missing").is_none());
+
+    // Test contains_key
+    assert!(obj.contains_key("num"));
+    assert!(!obj.contains_key("missing"));
+
+    // Test len/is_empty
+    assert_eq!(obj.len(), 2);
+    assert!(!obj.is_empty());
+
+    let empty_obj = Object(BTreeMap::new());
+    assert_eq!(empty_obj.len(), 0);
+    assert!(empty_obj.is_empty());
+
+    // Test indexing
+    assert_eq!(&obj["num"], &Data::Integer(42));
+
+    // Test iterators
+    assert_eq!(obj.keys().count(), 2);
+    assert_eq!(obj.values().count(), 2);
+    assert_eq!(obj.iter().count(), 2);
+}
+
+#[test]
+fn test_array_methods() {
+    let arr = Array(vec![Data::Integer(1), Data::Integer(2), Data::Integer(3)]);
+
+    // Test get
+    assert_eq!(arr.get(0), Some(&Data::Integer(1)));
+    assert_eq!(arr.get(2), Some(&Data::Integer(3)));
+    assert!(arr.get(3).is_none());
+
+    // Test len/is_empty
+    assert_eq!(arr.len(), 3);
+    assert!(!arr.is_empty());
+
+    let empty_arr = Array(vec![]);
+    assert_eq!(empty_arr.len(), 0);
+    assert!(empty_arr.is_empty());
+
+    // Test indexing
+    assert_eq!(&arr[1], &Data::Integer(2));
+
+    // Test iterator
+    assert_eq!(arr.iter().count(), 3);
+}
+
+#[test]
+fn test_get_at_path_simple() {
+    // Build nested structure: {"embed": {"alt": "test"}}
+    let mut inner = BTreeMap::new();
+    inner.insert(SmolStr::new_static("alt"), Data::String(AtprotoStr::String("test".into())));
+
+    let mut outer = BTreeMap::new();
+    outer.insert(SmolStr::new_static("embed"), Data::Object(Object(inner)));
+
+    let data = Data::Object(Object(outer));
+
+    // Test simple field access
+    let result = data.get_at_path("embed.alt");
+    assert!(result.is_some());
+    assert_eq!(result.unwrap().as_str(), Some("test"));
+
+    // Test with leading dot
+    let result2 = data.get_at_path(".embed.alt");
+    assert!(result2.is_some());
+    assert_eq!(result2.unwrap().as_str(), Some("test"));
+
+    // Test missing path
+    assert!(data.get_at_path("missing.field").is_none());
+    assert!(data.get_at_path("embed.missing").is_none());
+}
+
+#[test]
+fn test_get_at_path_arrays() {
+    // Build: {"items": [{"name": "first"}, {"name": "second"}]}
+    let mut item1 = BTreeMap::new();
+    item1.insert(SmolStr::new_static("name"), Data::String(AtprotoStr::String("first".into())));
+
+    let mut item2 = BTreeMap::new();
+    item2.insert(SmolStr::new_static("name"), Data::String(AtprotoStr::String("second".into())));
+
+    let items = Data::Array(Array(vec![
+        Data::Object(Object(item1)),
+        Data::Object(Object(item2)),
+    ]));
+
+    let mut outer = BTreeMap::new();
+    outer.insert(SmolStr::new_static("items"), items);
+    let data = Data::Object(Object(outer));
+
+    // Test array indexing
+    let result = data.get_at_path("items[0].name");
+    assert!(result.is_some());
+    assert_eq!(result.unwrap().as_str(), Some("first"));
+
+    let result2 = data.get_at_path("items[1].name");
+    assert!(result2.is_some());
+    assert_eq!(result2.unwrap().as_str(), Some("second"));
+
+    // Test out of bounds
+    assert!(data.get_at_path("items[2].name").is_none());
+}
+
+#[test]
+fn test_get_at_path_complex() {
+    // Build: {"post": {"embed": {"images": [{"alt": "img1"}, {"alt": "img2"}]}}}
+    let mut img1 = BTreeMap::new();
+    img1.insert(SmolStr::new_static("alt"), Data::String(AtprotoStr::String("img1".into())));
+
+    let mut img2 = BTreeMap::new();
+    img2.insert(SmolStr::new_static("alt"), Data::String(AtprotoStr::String("img2".into())));
+
+    let images = Data::Array(Array(vec![
+        Data::Object(Object(img1)),
+        Data::Object(Object(img2)),
+    ]));
+
+    let mut embed_map = BTreeMap::new();
+    embed_map.insert(SmolStr::new_static("images"), images);
+
+    let mut post_map = BTreeMap::new();
+    post_map.insert(SmolStr::new_static("embed"), Data::Object(Object(embed_map)));
+
+    let mut root = BTreeMap::new();
+    root.insert(SmolStr::new_static("post"), Data::Object(Object(post_map)));
+
+    let data = Data::Object(Object(root));
+
+    // Test complex nested path
+    let result = data.get_at_path("post.embed.images[1].alt");
+    assert!(result.is_some());
+    assert_eq!(result.unwrap().as_str(), Some("img2"));
+}
+
+#[test]
+fn test_rawdata_get_at_path() {
+    // Build nested RawData structure
+    let mut inner = BTreeMap::new();
+    inner.insert(SmolStr::new_static("value"), RawData::SignedInt(42));
+
+    let mut outer = BTreeMap::new();
+    outer.insert(SmolStr::new_static("nested"), RawData::Object(inner));
+
+    let data = RawData::Object(outer);
+
+    // Test simple field access
+    let result = data.get_at_path("nested.value");
+    assert!(result.is_some());
+    if let Some(RawData::SignedInt(n)) = result {
+        assert_eq!(*n, 42);
+    } else {
+        panic!("Expected SignedInt");
+    }
+}
+
+#[test]
+fn test_query_exact_path() {
+    let mut inner = BTreeMap::new();
+    inner.insert(SmolStr::new_static("handle"), Data::String(AtprotoStr::String("alice.bsky.social".into())));
+
+    let mut outer = BTreeMap::new();
+    outer.insert(SmolStr::new_static("author"), Data::Object(Object(inner)));
+
+    let data = Data::Object(Object(outer));
+
+    // Exact path should return Single
+    let result = data.query("author.handle");
+    assert!(matches!(result, QueryResult::Single(_)));
+    assert_eq!(result.single().unwrap().as_str(), Some("alice.bsky.social"));
+}
+
+#[test]
+fn test_query_wildcard_array() {
+    // Build: {"actors": [{"handle": "alice"}, {"handle": "bob"}, {"name": "carol"}]}
+    let mut actor1 = BTreeMap::new();
+    actor1.insert(SmolStr::new_static("handle"), Data::String(AtprotoStr::String("alice".into())));
+
+    let mut actor2 = BTreeMap::new();
+    actor2.insert(SmolStr::new_static("handle"), Data::String(AtprotoStr::String("bob".into())));
+
+    let mut actor3 = BTreeMap::new();
+    actor3.insert(SmolStr::new_static("name"), Data::String(AtprotoStr::String("carol".into())));
+
+    let actors = Data::Array(Array(vec![
+        Data::Object(Object(actor1)),
+        Data::Object(Object(actor2)),
+        Data::Object(Object(actor3)),
+    ]));
+
+    let mut root = BTreeMap::new();
+    root.insert(SmolStr::new_static("actors"), actors);
+    let data = Data::Object(Object(root));
+
+    // Wildcard over array
+    let result = data.query("actors.[..]");
+    assert!(matches!(result, QueryResult::Multiple(_)));
+    let matches = result.multiple().unwrap();
+    assert_eq!(matches.len(), 3);
+    assert_eq!(matches[0].path.as_str(), "actors[0]");
+    assert_eq!(matches[1].path.as_str(), "actors[1]");
+    assert_eq!(matches[2].path.as_str(), "actors[2]");
+}
+
+#[test]
+fn test_query_wildcard_object() {
+    // Build: {"embed": {"images": {...}, "video": {...}}}
+    let mut images = BTreeMap::new();
+    images.insert(SmolStr::new_static("alt"), Data::String(AtprotoStr::String("img".into())));
+
+    let mut video = BTreeMap::new();
+    video.insert(SmolStr::new_static("alt"), Data::String(AtprotoStr::String("vid".into())));
+
+    let mut embed = BTreeMap::new();
+    embed.insert(SmolStr::new_static("images"), Data::Object(Object(images)));
+    embed.insert(SmolStr::new_static("video"), Data::Object(Object(video)));
+
+    let mut root = BTreeMap::new();
+    root.insert(SmolStr::new_static("embed"), Data::Object(Object(embed)));
+    let data = Data::Object(Object(root));
+
+    // Wildcard over object values
+    let result = data.query("embed.[..]");
+    assert!(matches!(result, QueryResult::Multiple(_)));
+    let matches = result.multiple().unwrap();
+    assert_eq!(matches.len(), 2); // images and video
+}
+
+#[test]
+fn test_query_scoped_recursion() {
+    // Build: {"post": {"author": {"profile": {"handle": "alice"}}}}
+    let mut handle_map = BTreeMap::new();
+    handle_map.insert(SmolStr::new_static("handle"), Data::String(AtprotoStr::String("alice".into())));
+
+    let mut profile_map = BTreeMap::new();
+    profile_map.insert(SmolStr::new_static("profile"), Data::Object(Object(handle_map)));
+
+    let mut author_map = BTreeMap::new();
+    author_map.insert(SmolStr::new_static("author"), Data::Object(Object(profile_map)));
+
+    let mut post_map = BTreeMap::new();
+    post_map.insert(SmolStr::new_static("post"), Data::Object(Object(author_map)));
+
+    let data = Data::Object(Object(post_map));
+
+    // Scoped recursion: find handle within post
+    let result = data.query("post..handle");
+    assert!(matches!(result, QueryResult::Single(_)));
+    assert_eq!(result.single().unwrap().as_str(), Some("alice"));
+    assert_eq!(result.first().unwrap().as_str(), Some("alice"));
+}
+
+#[test]
+fn test_query_global_recursion() {
+    // Build structure with multiple 'cid' fields at different depths
+    let mut inner1 = BTreeMap::new();
+    inner1.insert(SmolStr::new_static("cid"), Data::String(AtprotoStr::String("cid1".into())));
+
+    let mut inner2 = BTreeMap::new();
+    inner2.insert(SmolStr::new_static("cid"), Data::String(AtprotoStr::String("cid2".into())));
+
+    let mut middle = BTreeMap::new();
+    middle.insert(SmolStr::new_static("post"), Data::Object(Object(inner1)));
+    middle.insert(SmolStr::new_static("reply"), Data::Object(Object(inner2)));
+
+    let mut root = BTreeMap::new();
+    root.insert(SmolStr::new_static("thread"), Data::Object(Object(middle)));
+    root.insert(SmolStr::new_static("cid"), Data::String(AtprotoStr::String("cid3".into())));
+
+    let data = Data::Object(Object(root));
+
+    // Global recursion: find all cids
+    let result = data.query("...cid");
+    assert!(matches!(result, QueryResult::Multiple(_)));
+    let matches = result.multiple().unwrap();
+    assert_eq!(matches.len(), 3);
+
+    // Check values
+    let values: Vec<_> = result.values().map(|d| d.as_str().unwrap()).collect();
+    assert!(values.contains(&"cid1"));
+    assert!(values.contains(&"cid2"));
+    assert!(values.contains(&"cid3"));
+}
+
+#[test]
+fn test_query_combined_wildcard_field() {
+    // Build: {"actors": [{"handle": "alice"}, {"handle": "bob"}]}
+    let mut actor1 = BTreeMap::new();
+    actor1.insert(SmolStr::new_static("handle"), Data::String(AtprotoStr::String("alice".into())));
+
+    let mut actor2 = BTreeMap::new();
+    actor2.insert(SmolStr::new_static("handle"), Data::String(AtprotoStr::String("bob".into())));
+
+    let actors = Data::Array(Array(vec![
+        Data::Object(Object(actor1)),
+        Data::Object(Object(actor2)),
+    ]));
+
+    let mut root = BTreeMap::new();
+    root.insert(SmolStr::new_static("actors"), actors);
+    let data = Data::Object(Object(root));
+
+    // Wildcard + field: collect handle from each actor
+    let result = data.query("actors.[..].handle");
+    assert!(matches!(result, QueryResult::Multiple(_)));
+    let matches = result.multiple().unwrap();
+    assert_eq!(matches.len(), 2);
+    assert_eq!(matches[0].value.unwrap().as_str(), Some("alice"));
+    assert_eq!(matches[1].value.unwrap().as_str(), Some("bob"));
+}
+
+#[test]
+fn test_query_no_match() {
+    let mut map = BTreeMap::new();
+    map.insert(SmolStr::new_static("foo"), Data::Integer(42));
+    let data = Data::Object(Object(map));
+
+    // Field doesn't exist
+    let result = data.query("missing");
+    assert!(matches!(result, QueryResult::None));
+    assert!(result.is_empty());
+    assert!(result.single().is_none());
+    assert!(result.first().is_none());
+}
+
+#[test]
+fn test_query_result_helpers() {
+    let mut map = BTreeMap::new();
+    map.insert(SmolStr::new_static("value"), Data::Integer(42));
+    let data = Data::Object(Object(map));
+
+    let result = data.query("value");
+
+    // Test helper methods
+    assert!(!result.is_empty());
+    assert!(result.single().is_some());
+    assert_eq!(result.first().unwrap().as_integer(), Some(42));
+
+    let values: Vec<_> = result.values().collect();
+    assert_eq!(values.len(), 1);
+}