+6

constellation/src/lib.rs

··· 50 50 } 51 51 } 52 52 53 53 + #[derive(Debug, PartialEq, Serialize, Deserialize, Clone, Default)] 54 54 + pub struct RecordsBySubject { 55 55 + pub subject: String, 56 56 + pub records: Vec<RecordId>, 57 57 + } 58 58 + 53 59 /// maybe the worst type in this repo, and there are some bad types 54 60 #[derive(Debug, Serialize, PartialEq)] 55 61 pub struct CountsByCount {

+3 -3

constellation/src/server/mod.rs

··· 17 17 use tokio::task::spawn_blocking; 18 18 use tokio_util::sync::CancellationToken; 19 19 20 20 - use crate::storage::{LinkReader, Order, StorageStats}; 21 21 - use crate::{CountsByCount, Did, RecordId}; 20 20 + use crate::storage::{LinkReader, StorageStats}; 21 21 + use crate::{CountsByCount, Did, RecordId, RecordsBySubject}; 22 22 23 23 mod acceptable; 24 24 mod filters; ··· 698 698 #[derive(Template, Serialize)] 699 699 #[template(path = "get-many-to-many.html.j2")] 700 700 struct GetManyToManyItemsResponse { 701 701 - linking_records: Vec<(String, Vec<RecordId>)>, 701 701 + linking_records: Vec<RecordsBySubject>, 702 702 cursor: Option<OpaqueApiCursor>, 703 703 #[serde(skip_serializing)] 704 704 query: GetManyToManyItemsQuery,

+9 -6

constellation/src/storage/mem_store.rs

··· 1 1 use super::{ 2 2 LinkReader, LinkStorage, Order, PagedAppendingCollection, PagedOrderedCollection, StorageStats, 3 3 }; 4 4 - use crate::{ActionableEvent, CountsByCount, Did, RecordId}; 4 4 + use crate::{ActionableEvent, CountsByCount, Did, RecordId, RecordsBySubject}; 5 5 use anyhow::Result; 6 6 use links::CollectedLink; 7 7 use std::collections::{HashMap, HashSet}; ··· 244 244 after: Option<String>, 245 245 filter_dids: &HashSet<Did>, 246 246 filter_to_targets: &HashSet<String>, 247 247 - ) -> Result<PagedOrderedCollection<(String, Vec<RecordId>), String>> { 247 247 + ) -> Result<PagedOrderedCollection<RecordsBySubject, String>> { 248 248 let empty_res = Ok(PagedOrderedCollection { 249 249 items: Vec::new(), 250 250 next: None, ··· 307 307 308 308 let mut items = grouped_links 309 309 .into_iter() 310 310 - .map(|(t, r)| (t.0, r)) 310 310 + .map(|(t, r)| RecordsBySubject { 311 311 + subject: t.0, 312 312 + records: r, 313 313 + }) 311 314 .collect::<Vec<_>>(); 312 315 313 313 - items.sort_by(|(a, _), (b, _)| a.cmp(b)); 316 316 + items.sort_by(|a, b| a.subject.cmp(&b.subject)); 314 317 315 318 items = items 316 319 .into_iter() 317 317 - .skip_while(|(t, _)| after.as_ref().map(|a| t <= a).unwrap_or(false)) 320 320 + .skip_while(|item| after.as_ref().map(|a| &item.subject <= a).unwrap_or(false)) 318 321 .take(limit as usize) 319 322 .collect(); 320 323 321 324 let next = if items.len() as u64 >= limit { 322 322 - items.last().map(|(t, _)| t.clone()) 325 325 + items.last().map(|item| item.subject.clone()) 323 326 } else { 324 327 None 325 328 };

+40 -24

constellation/src/storage/mod.rs

··· 1 1 - use crate::{ActionableEvent, CountsByCount, Did, RecordId}; 1 1 + use crate::{ActionableEvent, CountsByCount, Did, RecordId, RecordsBySubject}; 2 2 use anyhow::Result; 3 3 use serde::{Deserialize, Serialize}; 4 4 use std::collections::{HashMap, HashSet}; ··· 145 145 after: Option<String>, 146 146 filter_dids: &HashSet<Did>, 147 147 filter_to_targets: &HashSet<String>, 148 148 - ) -> Result<PagedOrderedCollection<(String, Vec<RecordId>), String>>; 148 148 + ) -> Result<PagedOrderedCollection<RecordsBySubject, String>>; 149 149 150 150 fn get_all_counts( 151 151 &self, ··· 1740 1740 &HashSet::new(), 1741 1741 )?, 1742 1742 PagedOrderedCollection { 1743 1743 - items: vec![( 1744 1744 - "b.com".to_string(), 1745 1745 - vec![RecordId { 1743 1743 + items: vec![RecordsBySubject { 1744 1744 + subject: "b.com".to_string(), 1745 1745 + records: vec![RecordId { 1746 1746 did: "did:plc:asdf".into(), 1747 1747 collection: "app.t.c".into(), 1748 1748 rkey: "asdf".into(), 1749 1749 }] 1750 1750 - )], 1750 1750 + }], 1751 1751 next: None, 1752 1752 } 1753 1753 ); ··· 1849 1849 assert_eq!(result.items.len(), 2); 1850 1850 assert_eq!(result.next, None); 1851 1851 // Find b.com group 1852 1852 - let (b_target, b_records) = result.items.iter().find(|(target, _)| target == "b.com").unwrap(); 1853 1853 - assert_eq!(b_target, "b.com"); 1854 1854 - assert_eq!(b_records.len(), 2); 1855 1855 - assert!(b_records.iter().any(|r| r.did.0 == "did:plc:asdf" && r.rkey == "asdf")); 1856 1856 - assert!(b_records.iter().any(|r| r.did.0 == "did:plc:asdf" && r.rkey == "asdf2")); 1852 1852 + let b_group = result 1853 1853 + .items 1854 1854 + .iter() 1855 1855 + .find(|group| group.subject == "b.com") 1856 1856 + .unwrap(); 1857 1857 + assert_eq!(b_group.subject, "b.com"); 1858 1858 + assert_eq!(b_group.records.len(), 2); 1859 1859 + assert!(b_group.records 1860 1860 + .iter() 1861 1861 + .any(|r| r.did.0 == "did:plc:asdf" && r.rkey == "asdf")); 1862 1862 + assert!(b_group.records 1863 1863 + .iter() 1864 1864 + .any(|r| r.did.0 == "did:plc:asdf" && r.rkey == "asdf2")); 1857 1865 // Find c.com group 1858 1858 - let (c_target, c_records) = result.items.iter().find(|(target, _)| target == "c.com").unwrap(); 1859 1859 - assert_eq!(c_target, "c.com"); 1860 1860 - assert_eq!(c_records.len(), 2); 1861 1861 - assert!(c_records.iter().any(|r| r.did.0 == "did:plc:fdsa" && r.rkey == "fdsa")); 1862 1862 - assert!(c_records.iter().any(|r| r.did.0 == "did:plc:fdsa" && r.rkey == "fdsa2")); 1866 1866 + let c_group = result 1867 1867 + .items 1868 1868 + .iter() 1869 1869 + .find(|group| group.subject == "c.com") 1870 1870 + .unwrap(); 1871 1871 + assert_eq!(c_group.subject, "c.com"); 1872 1872 + assert_eq!(c_group.records.len(), 2); 1873 1873 + assert!(c_group.records 1874 1874 + .iter() 1875 1875 + .any(|r| r.did.0 == "did:plc:fdsa" && r.rkey == "fdsa")); 1876 1876 + assert!(c_group.records 1877 1877 + .iter() 1878 1878 + .any(|r| r.did.0 == "did:plc:fdsa" && r.rkey == "fdsa2")); 1863 1879 1864 1880 // Test with DID filter - should only get records from did:plc:fdsa 1865 1881 let result = storage.get_many_to_many( ··· 1873 1889 &HashSet::new(), 1874 1890 )?; 1875 1891 assert_eq!(result.items.len(), 1); 1876 1876 - let (target, records) = &result.items[0]; 1877 1877 - assert_eq!(target, "c.com"); 1878 1878 - assert_eq!(records.len(), 2); 1879 1879 - assert!(records.iter().all(|r| r.did.0 == "did:plc:fdsa")); 1892 1892 + let group = &result.items[0]; 1893 1893 + assert_eq!(group.subject, "c.com"); 1894 1894 + assert_eq!(group.records.len(), 2); 1895 1895 + assert!(group.records.iter().all(|r| r.did.0 == "did:plc:fdsa")); 1880 1896 1881 1897 // Test with target filter - should only get records linking to b.com 1882 1898 let result = storage.get_many_to_many( ··· 1890 1906 &HashSet::from_iter(["b.com".to_string()]), 1891 1907 )?; 1892 1908 assert_eq!(result.items.len(), 1); 1893 1893 - let (target, records) = &result.items[0]; 1894 1894 - assert_eq!(target, "b.com"); 1895 1895 - assert_eq!(records.len(), 2); 1896 1896 - assert!(records.iter().all(|r| r.did.0 == "did:plc:asdf")); 1909 1909 + let group = &result.items[0]; 1910 1910 + assert_eq!(group.subject, "b.com"); 1911 1911 + assert_eq!(group.records.len(), 2); 1912 1912 + assert!(group.records.iter().all(|r| r.did.0 == "did:plc:asdf")); 1897 1913 }); 1898 1914 }

+7 -4

constellation/src/storage/rocks_store.rs

··· 2 2 ActionableEvent, LinkReader, LinkStorage, Order, PagedAppendingCollection, 3 3 PagedOrderedCollection, StorageStats, 4 4 }; 5 5 - use crate::{CountsByCount, Did, RecordId}; 5 5 + use crate::{CountsByCount, Did, RecordId, RecordsBySubject}; 6 6 use anyhow::{bail, Result}; 7 7 use bincode::Options as BincodeOptions; 8 8 use links::CollectedLink; ··· 1132 1132 after: Option<String>, 1133 1133 filter_dids: &HashSet<Did>, 1134 1134 filter_to_targets: &HashSet<String>, 1135 1135 - ) -> Result<PagedOrderedCollection<(String, Vec<RecordId>), String>> { 1135 1135 + ) -> Result<PagedOrderedCollection<RecordsBySubject, String>> { 1136 1136 let collection = Collection(collection.to_string()); 1137 1137 let path = RPath(path.to_string()); 1138 1138 ··· 1241 1241 } 1242 1242 } 1243 1243 1244 1244 - let mut items: Vec<(String, Vec<RecordId>)> = Vec::with_capacity(grouped_links.len()); 1244 1244 + let mut items: Vec<RecordsBySubject> = Vec::with_capacity(grouped_links.len()); 1245 1245 for (fwd_target_id, records) in &grouped_links { 1246 1246 let Some(target_key) = self 1247 1247 .target_id_table ··· 1253 1253 1254 1254 let target_string = target_key.0 .0; 1255 1255 1256 1256 - items.push((target_string, records.clone())); 1256 1256 + items.push(RecordsBySubject { 1257 1257 + subject: target_string, 1258 1258 + records: records.clone(), 1259 1259 + }); 1257 1260 } 1258 1261 1259 1262 let next = if grouped_links.len() as u64 >= limit {

+3 -3

constellation/templates/get-many-to-many.html.j2

··· 23 23 24 24 <h3>Many-to-many links, most recent first:</h3> 25 25 26 26 - {% for (target, records) in linking_records %} 27 27 - <h4>Target: <code>{{ target }}</code> <small>(<a href="/links/all?target={{ target|urlencode }}">view all links</a>)</small></h4> 28 28 - {% for record in records %} 26 26 + {% for group in linking_records %} 27 27 + <h4>Target: <code>{{ group.subject }}</code> <small>(<a href="/links/all?target={{ group.subject|urlencode }}">view all links</a>)</small></h4> 28 28 + {% for record in group.records %} 29 29 <pre style="display: block; margin: 1em 2em" class="code"><strong>DID</strong>: {{ record.did().0 }} 30 30 <strong>Collection</strong>: {{ record.collection }} 31 31 <strong>RKey</strong>: {{ record.rkey }}

+109

lexicons/blue.microcosm/links/getManyToMany.json

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "blue.microcosm.links.getManyToMany", 4 4 + "defs": { 5 5 + "main": { 6 6 + "type": "query", 7 7 + "description": "Get records that link to a primary subject, grouped by the secondary subjects they also reference", 8 8 + "parameters": { 9 9 + "type": "params", 10 10 + "required": ["subject", "source", "pathToOther"], 11 11 + "properties": { 12 12 + "subject": { 13 13 + "type": "string", 14 14 + "format": "uri", 15 15 + "description": "the primary target being linked to (at-uri, did, or uri)" 16 16 + }, 17 17 + "source": { 18 18 + "type": "string", 19 19 + "description": "collection and path specification for the primary link (e.g., 'app.bsky.feed.like:subject.uri')" 20 20 + }, 21 21 + "pathToOther": { 22 22 + "type": "string", 23 23 + "description": "path to the secondary link in the many-to-many record (e.g., 'otherThing.uri')" 24 24 + }, 25 25 + "did": { 26 26 + "type": "array", 27 27 + "description": "filter links to those from specific users", 28 28 + "items": { 29 29 + "type": "string", 30 30 + "format": "did" 31 31 + } 32 32 + }, 33 33 + "otherSubject": { 34 34 + "type": "array", 35 35 + "description": "filter secondary links to specific subjects", 36 36 + "items": { 37 37 + "type": "string" 38 38 + } 39 39 + }, 40 40 + "limit": { 41 41 + "type": "integer", 42 42 + "minimum": 1, 43 43 + "maximum": 100, 44 44 + "default": 16, 45 45 + "description": "number of results to return" 46 46 + } 47 47 + } 48 48 + }, 49 49 + "output": { 50 50 + "encoding": "application/json", 51 51 + "schema": { 52 52 + "type": "object", 53 53 + "required": ["linking_records"], 54 54 + "properties": { 55 55 + "linking_records": { 56 56 + "type": "array", 57 57 + "items": { 58 58 + "type": "ref", 59 59 + "ref": "#recordsBySubject" 60 60 + } 61 61 + }, 62 62 + "cursor": { 63 63 + "type": "string", 64 64 + "description": "pagination cursor" 65 65 + } 66 66 + } 67 67 + } 68 68 + } 69 69 + }, 70 70 + "recordsBySubject": { 71 71 + "type": "object", 72 72 + "required": ["subject", "records"], 73 73 + "properties": { 74 74 + "subject": { 75 75 + "type": "string", 76 76 + "description": "the secondary subject that these records link to" 77 77 + }, 78 78 + "records": { 79 79 + "type": "array", 80 80 + "items": { 81 81 + "type": "ref", 82 82 + "ref": "#linkRecord" 83 83 + } 84 84 + } 85 85 + } 86 86 + }, 87 87 + "linkRecord": { 88 88 + "type": "object", 89 89 + "required": ["did", "collection", "rkey"], 90 90 + "description": "A record identifier consisting of a DID, collection, and record key", 91 91 + "properties": { 92 92 + "did": { 93 93 + "type": "string", 94 94 + "format": "did", 95 95 + "description": "the DID of the linking record's repository" 96 96 + }, 97 97 + "collection": { 98 98 + "type": "string", 99 99 + "format": "nsid", 100 100 + "description": "the collection of the linking record" 101 101 + }, 102 102 + "rkey": { 103 103 + "type": "string", 104 104 + "format": "record-key" 105 105 + } 106 106 + } 107 107 + } 108 108 + } 109 109 + }