microcosm.blue
the derives came in from base64 in tangled#7, whic was removed.
the cursor is a composite, but we might have other composite cursors that are different -- renaming this one to reflect its specific purpose.
+17
-2
constellation/src/lib.rs
+17
-2
constellation/src/lib.rs
···
22
22
DeleteAccount(Did),
23
23
}
24
24
25
-
#[derive(Debug, Hash, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
25
+
#[derive(Debug, PartialEq, Eq, Hash, Clone, Serialize, Deserialize)]
26
26
pub struct Did(pub String);
27
27
28
28
impl<T: Into<String>> From<T> for Did {
···
31
31
}
32
32
}
33
33
34
-
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, PartialOrd, Ord)]
34
+
#[derive(Debug, PartialEq, Serialize, Deserialize)]
35
35
pub struct RecordId {
36
36
pub did: Did,
37
37
pub collection: String,
···
48
48
pub fn rkey(&self) -> String {
49
49
self.rkey.clone()
50
50
}
51
+
pub fn uri(&self) -> String {
52
+
let RecordId {
53
+
did: Did(did),
54
+
collection,
55
+
rkey,
56
+
} = self;
57
+
format!("at://{did}/{collection}/{rkey}")
58
+
}
59
+
}
60
+
61
+
#[derive(Debug, Serialize, PartialEq)]
62
+
#[serde(rename_all = "camelCase")]
63
+
pub struct ManyToManyItem {
64
+
link_record: RecordId,
65
+
other_subject: String,
51
66
}
52
67
53
68
/// maybe the worst type in this repo, and there are some bad types
+9
-18
constellation/src/server/mod.rs
+9
-18
constellation/src/server/mod.rs
···
18
18
use tokio_util::sync::CancellationToken;
19
19
20
20
use crate::storage::{LinkReader, Order, StorageStats};
21
-
use crate::{CountsByCount, Did, RecordId};
21
+
use crate::{CountsByCount, Did, ManyToManyItem, RecordId};
22
22
23
23
mod acceptable;
24
24
mod filters;
···
278
278
/// path to the secondary link in the linking record
279
279
path_to_other: String,
280
280
/// filter to linking records (join of the m2m) by these DIDs
281
+
///
282
+
/// TODO: this should be called `link_did`, deprecate + add an alias
283
+
/// TODO: should we have an `other_did` filter as well?
281
284
#[serde(default)]
282
285
did: Vec<String>,
283
286
/// filter to specific secondary records
···
686
689
/// path to the secondary link in the linking record
687
690
path_to_other: String,
688
691
/// filter to linking records (join of the m2m) by these DIDs
692
+
///
693
+
/// TODO: should we have an `other_did` filter as well?
689
694
#[serde(default)]
690
-
did: Vec<String>,
695
+
link_did: Vec<String>,
691
696
/// filter to specific secondary records
692
697
#[serde(default)]
693
698
other_subject: Vec<String>,
694
699
cursor: Option<OpaqueApiCursor>,
695
700
#[serde(default = "get_default_cursor_limit")]
696
701
limit: u64,
697
-
}
698
-
#[derive(Debug, Serialize, Clone)]
699
-
struct ManyToManyItem {
700
-
link: RecordId,
701
-
subject: String,
702
702
}
703
703
#[derive(Template, Serialize)]
704
704
#[template(path = "get-many-to-many.html.j2")]
···
726
726
}
727
727
728
728
let filter_dids: HashSet<Did> = query
729
-
.did
729
+
.link_did
730
730
.iter()
731
731
.map(|d| d.trim())
732
732
.filter(|d| !d.is_empty())
···
763
763
764
764
let cursor = paged.next.map(|next| ApiKeyedCursor { next }.into());
765
765
766
-
let items: Vec<ManyToManyItem> = paged
767
-
.items
768
-
.into_iter()
769
-
.map(|(record_id, subject)| ManyToManyItem {
770
-
link: record_id,
771
-
subject,
772
-
})
773
-
.collect();
774
-
775
766
Ok(acceptable(
776
767
accept,
777
768
GetManyToManyItemsResponse {
778
-
items,
769
+
items: paged.items,
779
770
cursor,
780
771
query: (*query).clone(),
781
772
},
+17
-18
constellation/src/storage/mem_store.rs
+17
-18
constellation/src/storage/mem_store.rs
···
1
1
use super::{
2
-
LinkReader, LinkStorage, Order, PagedAppendingCollection, PagedOrderedCollection, StorageStats,
2
+
LinkReader, LinkStorage, ManyToManyCursor, Order, PagedAppendingCollection,
3
+
PagedOrderedCollection, StorageStats,
3
4
};
4
-
use crate::storage::CompositeCursor;
5
-
use crate::{ActionableEvent, CountsByCount, Did, RecordId};
5
+
use crate::{ActionableEvent, CountsByCount, Did, ManyToManyItem, RecordId};
6
6
7
7
use anyhow::{anyhow, Result};
8
8
use links::CollectedLink;
···
248
248
after: Option<String>,
249
249
filter_dids: &HashSet<Did>,
250
250
filter_targets: &HashSet<String>,
251
-
) -> Result<PagedOrderedCollection<(RecordId, String), String>> {
251
+
) -> Result<PagedOrderedCollection<ManyToManyItem, String>> {
252
252
// setup variables that we need later
253
253
let path_to_other = RecordPath(path_to_other.to_string());
254
254
let filter_targets: HashSet<Target> =
···
264
264
let f = f
265
265
.parse::<u64>()
266
266
.map_err(|e| anyhow!("invalid cursor.1: {e}"))?;
267
-
Some(CompositeCursor {
268
-
backward: b,
269
-
forward: f,
267
+
Some(ManyToManyCursor {
268
+
backlink: b,
269
+
forward_link: f,
270
270
})
271
271
}
272
272
None => None,
···
280
280
return Ok(PagedOrderedCollection::empty());
281
281
};
282
282
283
-
let mut items: Vec<(usize, usize, RecordId, String)> = Vec::new();
283
+
let mut items: Vec<(usize, usize, ManyToManyItem)> = Vec::new();
284
284
285
285
// iterate backwards (who linked to the target?)
286
286
for (linker_idx, (did, rkey)) in linkers
287
287
.iter()
288
288
.enumerate()
289
289
.filter_map(|(i, opt)| opt.as_ref().map(|v| (i, v)))
290
-
.skip_while(|(linker_idx, _)| cursor.is_some_and(|c| *linker_idx < c.backward as usize))
290
+
.skip_while(|(linker_idx, _)| cursor.is_some_and(|c| *linker_idx < c.backlink as usize))
291
291
.filter(|(_, (did, _))| filter_dids.is_empty() || filter_dids.contains(did))
292
292
{
293
293
let Some(links) = data.links.get(did).and_then(|m| {
···
308
308
})
309
309
.skip_while(|(link_idx, _)| {
310
310
cursor.is_some_and(|c| {
311
-
linker_idx == c.backward as usize && *link_idx <= c.forward as usize
311
+
linker_idx == c.backlink as usize && *link_idx <= c.forward_link as usize
312
312
})
313
313
})
314
314
.take(limit as usize + 1 - items.len())
315
315
{
316
-
items.push((
317
-
linker_idx,
318
-
link_idx,
319
-
RecordId {
316
+
let item = ManyToManyItem {
317
+
link_record: RecordId {
320
318
did: did.clone(),
321
319
collection: collection.to_string(),
322
320
rkey: rkey.0.clone(),
323
321
},
324
-
fwd_target.0.clone(),
325
-
));
322
+
other_subject: fwd_target.0.clone(),
323
+
};
324
+
items.push((linker_idx, link_idx, item));
326
325
}
327
326
328
327
// page full - eject
···
332
331
}
333
332
334
333
let next = (items.len() > limit as usize).then(|| {
335
-
let (l, f, _, _) = items[limit as usize - 1];
334
+
let (l, f, _) = items[limit as usize - 1];
336
335
format!("{l},{f}")
337
336
});
338
337
339
338
let items = items
340
339
.into_iter()
341
340
.take(limit as usize)
342
-
.map(|(_, _, rid, t)| (rid, t))
341
+
.map(|(_, _, item)| item)
343
342
.collect();
344
343
345
344
Ok(PagedOrderedCollection { items, next })
+53
-29
constellation/src/storage/mod.rs
+53
-29
constellation/src/storage/mod.rs
···
1
-
use crate::{ActionableEvent, CountsByCount, Did, RecordId};
1
+
use crate::{ActionableEvent, CountsByCount, Did, ManyToManyItem, RecordId};
2
2
use anyhow::Result;
3
3
use serde::{Deserialize, Serialize};
4
4
use std::collections::{HashMap, HashSet};
···
39
39
}
40
40
}
41
41
42
-
// get-many-to-many composite cursor
43
42
#[derive(Copy, Clone, Debug)]
44
-
struct CompositeCursor {
45
-
backward: u64,
46
-
forward: u64,
43
+
struct ManyToManyCursor {
44
+
backlink: u64,
45
+
forward_link: u64,
47
46
}
48
47
49
48
/// A paged collection whose keys are sorted instead of indexed
···
153
152
after: Option<String>,
154
153
filter_dids: &HashSet<Did>,
155
154
filter_to_targets: &HashSet<String>,
156
-
) -> Result<PagedOrderedCollection<(RecordId, String), String>>;
155
+
) -> Result<PagedOrderedCollection<ManyToManyItem, String>>;
157
156
158
157
fn get_all_counts(
159
158
&self,
···
1818
1817
2,
1819
1818
"both forward links at path_to_other should be emitted"
1820
1819
);
1821
-
let mut targets: Vec<_> = result.items.iter().map(|(_, t)| t.as_str()).collect();
1820
+
let mut targets: Vec<_> = result
1821
+
.items
1822
+
.iter()
1823
+
.map(|item| item.other_subject.as_str())
1824
+
.collect();
1822
1825
targets.sort();
1823
1826
assert_eq!(targets, vec!["b.com", "c.com"]);
1824
1827
assert!(result
1825
1828
.items
1826
1829
.iter()
1827
-
.all(|(r, _)| r.did.0 == "did:plc:asdf" && r.rkey == "asdf"));
1830
+
.all(|item| item.link_record.uri() == "at://did:plc:asdf/app.t.c/asdf"));
1828
1831
assert_eq!(result.next, None);
1829
1832
});
1830
1833
···
1927
1930
let b_items: Vec<_> = result
1928
1931
.items
1929
1932
.iter()
1930
-
.filter(|(_, subject)| subject == "b.com")
1933
+
.filter(|item| item.other_subject == "b.com")
1931
1934
.collect();
1932
1935
assert_eq!(b_items.len(), 2);
1933
-
assert!(b_items
1934
-
.iter()
1935
-
.any(|(r, _)| r.did.0 == "did:plc:asdf" && r.rkey == "asdf"));
1936
-
assert!(b_items
1937
-
.iter()
1938
-
.any(|(r, _)| r.did.0 == "did:plc:asdf" && r.rkey == "asdf2"));
1936
+
assert!(b_items.iter().any(
1937
+
|item| item.link_record.did.0 == "did:plc:asdf" && item.link_record.rkey == "asdf"
1938
+
));
1939
+
assert!(b_items.iter().any(
1940
+
|item| item.link_record.did.0 == "did:plc:asdf" && item.link_record.rkey == "asdf2"
1941
+
));
1939
1942
// Check c.com items
1940
1943
let c_items: Vec<_> = result
1941
1944
.items
1942
1945
.iter()
1943
-
.filter(|(_, subject)| subject == "c.com")
1946
+
.filter(|item| item.other_subject == "c.com")
1944
1947
.collect();
1945
1948
assert_eq!(c_items.len(), 2);
1946
-
assert!(c_items
1947
-
.iter()
1948
-
.any(|(r, _)| r.did.0 == "did:plc:fdsa" && r.rkey == "fdsa"));
1949
-
assert!(c_items
1950
-
.iter()
1951
-
.any(|(r, _)| r.did.0 == "did:plc:fdsa" && r.rkey == "fdsa2"));
1949
+
assert!(c_items.iter().any(
1950
+
|item| item.link_record.did.0 == "did:plc:fdsa" && item.link_record.rkey == "fdsa"
1951
+
));
1952
+
assert!(c_items.iter().any(
1953
+
|item| item.link_record.did.0 == "did:plc:fdsa" && item.link_record.rkey == "fdsa2"
1954
+
));
1952
1955
1953
1956
// Test with DID filter - should only get records from did:plc:fdsa
1954
1957
let result = storage.get_many_to_many(
···
1962
1965
&HashSet::new(),
1963
1966
)?;
1964
1967
assert_eq!(result.items.len(), 2);
1965
-
assert!(result.items.iter().all(|(_, subject)| subject == "c.com"));
1966
-
assert!(result.items.iter().all(|(r, _)| r.did.0 == "did:plc:fdsa"));
1968
+
assert!(result
1969
+
.items
1970
+
.iter()
1971
+
.all(|item| item.other_subject == "c.com"));
1972
+
assert!(result
1973
+
.items
1974
+
.iter()
1975
+
.all(|item| item.link_record.did.0 == "did:plc:fdsa"));
1967
1976
1968
1977
// Test with target filter - should only get records linking to b.com
1969
1978
let result = storage.get_many_to_many(
···
1977
1986
&HashSet::from_iter(["b.com".to_string()]),
1978
1987
)?;
1979
1988
assert_eq!(result.items.len(), 2);
1980
-
assert!(result.items.iter().all(|(_, subject)| subject == "b.com"));
1981
-
assert!(result.items.iter().all(|(r, _)| r.did.0 == "did:plc:asdf"));
1989
+
assert!(result
1990
+
.items
1991
+
.iter()
1992
+
.all(|item| item.other_subject == "b.com"));
1993
+
assert!(result
1994
+
.items
1995
+
.iter()
1996
+
.all(|item| item.link_record.did.0 == "did:plc:asdf"));
1982
1997
1983
1998
// Pagination edge cases: we have 4 flat items
1984
1999
···
2052
2067
assert_eq!(result2.next, None, "next should be None on final page");
2053
2068
2054
2069
// Verify we got all 4 unique items across both pages (no duplicates, no gaps)
2055
-
let mut all_rkeys: Vec<_> = result.items.iter().map(|(r, _)| r.rkey.clone()).collect();
2056
-
all_rkeys.extend(result2.items.iter().map(|(r, _)| r.rkey.clone()));
2070
+
let mut all_rkeys: Vec<_> = result
2071
+
.items
2072
+
.iter()
2073
+
.map(|item| item.link_record.rkey.clone())
2074
+
.collect();
2075
+
all_rkeys.extend(
2076
+
result2
2077
+
.items
2078
+
.iter()
2079
+
.map(|item| item.link_record.rkey.clone()),
2080
+
);
2057
2081
all_rkeys.sort();
2058
2082
assert_eq!(
2059
2083
all_rkeys,
···
2131
2155
.items
2132
2156
.iter()
2133
2157
.chain(page2.items.iter())
2134
-
.map(|(_, t)| t.clone())
2158
+
.map(|item| item.other_subject.clone())
2135
2159
.collect();
2136
2160
all_targets.sort();
2137
2161
assert_eq!(
+22
-24
constellation/src/storage/rocks_store.rs
+22
-24
constellation/src/storage/rocks_store.rs
···
1
1
use super::{
2
-
ActionableEvent, LinkReader, LinkStorage, Order, PagedAppendingCollection,
2
+
ActionableEvent, LinkReader, LinkStorage, ManyToManyCursor, Order, PagedAppendingCollection,
3
3
PagedOrderedCollection, StorageStats,
4
4
};
5
-
use crate::storage::CompositeCursor;
6
-
use crate::{CountsByCount, Did, RecordId};
5
+
use crate::{CountsByCount, Did, ManyToManyItem, RecordId};
7
6
8
7
use anyhow::{anyhow, bail, Result};
9
8
use bincode::Options as BincodeOptions;
···
946
945
path_to_other: &str,
947
946
limit: u64,
948
947
after: Option<String>,
949
-
filter_dids: &HashSet<Did>,
948
+
filter_link_dids: &HashSet<Did>,
950
949
filter_to_targets: &HashSet<String>,
951
950
) -> Result<PagedOrderedCollection<(String, u64, u64), String>> {
952
951
let collection = Collection(collection.to_string());
···
962
961
let after = after.map(|s| s.parse::<u64>().map(TargetId)).transpose()?;
963
962
964
963
let Some(target_id) = self.target_id_table.get_id_val(&self.db, &target_key)? else {
965
-
eprintln!("nothin doin for this target, {target_key:?}");
966
964
return Ok(PagedOrderedCollection::empty());
967
965
};
968
966
969
-
let filter_did_ids: HashMap<DidId, bool> = filter_dids
967
+
let filter_did_ids: HashMap<DidId, bool> = filter_link_dids
970
968
.iter()
971
969
.filter_map(|did| self.did_id_table.get_id_val(&self.db, did).transpose())
972
970
.collect::<Result<Vec<DidIdValue>>>()?
···
1023
1021
.take(1)
1024
1022
.next()
1025
1023
else {
1026
-
eprintln!("no forward match");
1027
1024
continue;
1028
1025
};
1029
1026
···
1135
1132
path_to_other: &str,
1136
1133
limit: u64,
1137
1134
after: Option<String>,
1138
-
filter_dids: &HashSet<Did>,
1135
+
filter_link_dids: &HashSet<Did>,
1139
1136
filter_to_targets: &HashSet<String>,
1140
-
) -> Result<PagedOrderedCollection<(RecordId, String), String>> {
1137
+
) -> Result<PagedOrderedCollection<ManyToManyItem, String>> {
1141
1138
// helper to resolve dids
1142
1139
let resolve_active_did = |did_id: &DidId| -> Result<Option<Did>> {
1143
1140
let Some(did) = self.did_id_table.get_val_from_id(&self.db, did_id.0)? else {
···
1165
1162
let f = f
1166
1163
.parse::<u64>()
1167
1164
.map_err(|e| anyhow!("invalid cursor.1: {e}"))?;
1168
-
Some(CompositeCursor {
1169
-
backward: b,
1170
-
forward: f,
1165
+
Some(ManyToManyCursor {
1166
+
backlink: b,
1167
+
forward_link: f,
1171
1168
})
1172
1169
}
1173
1170
None => None,
1174
1171
};
1175
1172
1176
-
eprintln!("cursor: {:#?}", cursor);
1177
-
1178
1173
// (__active__) did ids and filter targets
1179
-
let filter_did_ids: HashMap<DidId, bool> = filter_dids
1174
+
let filter_did_ids: HashMap<DidId, bool> = filter_link_dids
1180
1175
.iter()
1181
1176
.filter_map(|did| self.did_id_table.get_id_val(&self.db, did).transpose())
1182
1177
.collect::<Result<Vec<DidIdValue>>>()?
···
1197
1192
};
1198
1193
let linkers = self.get_target_linkers(&target_id)?;
1199
1194
1200
-
let mut items: Vec<(usize, usize, RecordId, String)> = Vec::new();
1195
+
let mut items: Vec<(usize, usize, ManyToManyItem)> = Vec::new();
1201
1196
1202
-
// iterate backwards (who linked to the target?)
1197
+
// iterate backlinks (who linked to the target?)
1203
1198
for (linker_idx, (did_id, rkey)) in
1204
1199
linkers.0.iter().enumerate().skip_while(|(linker_idx, _)| {
1205
-
cursor.is_some_and(|c| *linker_idx < c.backward as usize)
1200
+
cursor.is_some_and(|c| *linker_idx < c.backlink as usize)
1206
1201
})
1207
1202
{
1208
1203
if did_id.is_empty()
···
1220
1215
continue;
1221
1216
};
1222
1217
1223
-
// iterate forward (which of these links point to the __other__ target?)
1218
+
// iterate fwd links (which of these links point to the __other__ target?)
1224
1219
for (link_idx, RecordLinkTarget(_, fwd_target_id)) in links
1225
1220
.0
1226
1221
.into_iter()
1227
1222
.enumerate()
1228
1223
.filter(|(_, RecordLinkTarget(rpath, target_id))| {
1229
-
eprintln!("rpath.0: {} vs. path_to_other: {path_to_other}", rpath.0);
1230
1224
rpath.0 == path_to_other
1231
1225
&& (filter_to_target_ids.is_empty()
1232
1226
|| filter_to_target_ids.contains(target_id))
1233
1227
})
1234
1228
.skip_while(|(link_idx, _)| {
1235
1229
cursor.is_some_and(|c| {
1236
-
linker_idx == c.backward as usize && *link_idx <= c.forward as usize
1230
+
linker_idx == c.backlink as usize && *link_idx <= c.forward_link as usize
1237
1231
})
1238
1232
})
1239
1233
.take(limit as usize + 1 - items.len())
···
1256
1250
collection: collection.0.clone(),
1257
1251
rkey: rkey.0.clone(),
1258
1252
};
1259
-
items.push((linker_idx, link_idx, record_id, fwd_target_key.0 .0));
1253
+
let item = ManyToManyItem {
1254
+
link_record: record_id,
1255
+
other_subject: fwd_target_key.0 .0,
1256
+
};
1257
+
items.push((linker_idx, link_idx, item));
1260
1258
}
1261
1259
1262
1260
// page full - eject
···
1275
1273
// forward_link_idx are skipped. This correctly resumes mid-record when
1276
1274
// a single backlinker has multiple forward links at path_to_other.
1277
1275
let next = (items.len() > limit as usize).then(|| {
1278
-
let (l, f, _, _) = items[limit as usize - 1];
1276
+
let (l, f, _) = items[limit as usize - 1];
1279
1277
format!("{l},{f}")
1280
1278
});
1281
1279
1282
1280
let items = items
1283
1281
.into_iter()
1284
1282
.take(limit as usize)
1285
-
.map(|(_, _, rid, t)| (rid, t))
1283
+
.map(|(_, _, item)| item)
1286
1284
.collect();
1287
1285
1288
1286
Ok(PagedOrderedCollection { items, next })
+13
-7
constellation/templates/get-many-to-many.html.j2
+13
-7
constellation/templates/get-many-to-many.html.j2
···
6
6
7
7
{% block content %}
8
8
9
-
{% call try_it::get_many_to_many(query.subject, query.source, query.path_to_other, query.did, query.other_subject, query.limit) %}
9
+
{% call try_it::get_many_to_many(query.subject, query.source, query.path_to_other, query.link_did, query.other_subject, query.limit) %}
10
10
11
11
<h2>
12
12
Many-to-many links to <code>{{ query.subject }}</code>
···
19
19
20
20
<ul>
21
21
<li>See all links to this target at <code>/links/all</code>: <a href="/links/all?target={{ query.subject|urlencode }}">/links/all?target={{ query.subject }}</a></li>
22
+
{# todo: add link to see many-to-many counts #}
22
23
</ul>
23
24
24
25
<h3>Many-to-many links, most recent first:</h3>
25
26
26
27
{% for item in items %}
27
-
<pre style="display: block; margin: 1em 2em" class="code"><strong>Subject</strong>: <a href="/links/all?target={{ item.subject|urlencode }}">{{ item.subject }}</a>
28
-
<strong>DID</strong>: {{ item.link.did().0 }}
29
-
<strong>Collection</strong>: {{ item.link.collection }}
30
-
<strong>RKey</strong>: {{ item.link.rkey }}
31
-
-> <a href="https://pdsls.dev/at://{{ item.link.did().0 }}/{{ item.link.collection }}/{{ item.link.rkey }}">browse record</a></pre>
28
+
<pre style="display: block; margin: 1em 2em" class="code"><strong>Linking record</strong>:
29
+
{%- if let Some(uri) = item.link_record.uri().as_str()|to_browseable %} <a href="{{ uri }}">browse link record</a>{% endif %}
30
+
DID: {{ item.link_record.did().0 }}
31
+
Collection: {{ item.link_record.collection() }}
32
+
RKey: {{ item.link_record.rkey() }}
33
+
<strong>Other subject</strong>: {{ item.other_subject }}
34
+
{%- if let Some(uri) = item.other_subject.as_str()|to_browseable %}
35
+
-> <a href="{{ uri }}">browse subject</a>
36
+
{%- endif %}
37
+
</pre>
32
38
{% endfor %}
33
39
34
40
{% if let Some(c) = cursor %}
···
36
42
<input type="hidden" name="subject" value="{{ query.subject }}" />
37
43
<input type="hidden" name="source" value="{{ query.source }}" />
38
44
<input type="hidden" name="pathToOther" value="{{ query.path_to_other }}" />
39
-
{% for did in query.did %}
45
+
{% for did in query.link_did %}
40
46
<input type="hidden" name="did" value="{{ did }}" />
41
47
{% endfor %}
42
48
{% for other in query.other_subject %}
+8
-1
constellation/templates/hello.html.j2
+8
-1
constellation/templates/hello.html.j2
···
99
99
</ul>
100
100
101
101
<p style="margin-bottom: 0"><strong>Try it:</strong></p>
102
-
{% call try_it::get_many_to_many("at://did:plc:a4pqq234yw7fqbddawjo7y35/app.bsky.feed.post/3m237ilwc372e", "app.bsky.feed.like:subject.uri", "reply.parent.uri", [""], [""], 16) %}
102
+
{% call try_it::get_many_to_many(
103
+
"at://did:plc:uyauirpjzk6le4ygqzatcwnq/app.bsky.graph.list/3lzhg33t5bf2h",
104
+
"app.bsky.graph.listitem:list",
105
+
"subject",
106
+
[""],
107
+
[""],
108
+
16,
109
+
) %}
103
110
104
111
105
112
<h3 class="route"><code>GET /links</code></h3>
+9
-7
lexicons/blue.microcosm/links/getManyToMany.json
+9
-7
lexicons/blue.microcosm/links/getManyToMany.json
···
4
4
"defs": {
5
5
"main": {
6
6
"type": "query",
7
-
"description": "Get records that link to a primary subject along with the secondary subjects they also reference",
7
+
"description": "Get records that link out to both a primary and secondary subject",
8
8
"parameters": {
9
9
"type": "params",
10
10
"required": ["subject", "source", "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
-
"did": {
25
+
"linkDid": {
26
26
"type": "array",
27
-
"description": "filter links to those from specific users",
27
+
"description": "filter linking records from specific users",
28
28
"items": {
29
29
"type": "string",
30
30
"format": "did"
···
68
68
},
69
69
"item": {
70
70
"type": "object",
71
-
"required": ["link", "subject"],
71
+
"required": ["linkRecord", "otherSubject"],
72
72
"properties": {
73
-
"link": {
73
+
"linkRecord": {
74
74
"type": "ref",
75
-
"ref": "#linkRecord"
75
+
"ref": "#linkRecord",
76
+
"description": "reference to the link record itself"
76
77
},
77
-
"subject": {
78
+
"otherSubject": {
79
+
"description": "the secondary subject from the link record",
78
80
"type": "string"
79
81
}
80
82
}
History
5 rounds
0 comments
bad-example.com
submitted
#4
6 commits
expand
collapse
clean up dervive traits, specific cursor name
the derives came in from base64 in tangled#7, whic was removed.
the cursor is a composite, but we might have other composite cursors that are different -- renaming this one to reflect its specific purpose.
bikeshed did filter name for m2m queries
remove some prints
ManyToManyItem and set default "try-it": listitems
update lexicon
and fix casing
add _idx suffix for clarity (thanks maxh!) +fwd->o
"forward links" now align a little on the "other link" terminology used in the client-facing api
(kind of regret "other" as a term but oh well!)
expand 0 comments
pull request successfully merged
bad-example.com
submitted
#3
5 commits
expand
collapse
clean up dervive traits, specific cursor name
the derives came in from base64 in tangled#7, whic was removed.
the cursor is a composite, but we might have other composite cursors that are different -- renaming this one to reflect its specific purpose.
bikeshed did filter name for m2m queries
remove some prints
ManyToManyItem and set default "try-it": listitems
update lexicon
and fix casing
expand 0 comments
bad-example.com
submitted
#2
5 commits
expand
collapse
clean up dervive traits, specific cursor name
the derives came in from base64 in tangled#7, whic was removed.
the cursor is a composite, but we might have other composite cursors that are different -- renaming this one to reflect its specific purpose.
bikeshed did filter name for m2m queries
remove some prints
ManyToManyItem and set default "try-it": listitems
update lexicon
and fix casing
expand 0 comments
bad-example.com
submitted
#1
4 commits
expand
collapse
clean up dervive traits, specific cursor name
the derives came in from base64 in tangled#7, whic was removed.
the cursor is a composite, but we might have other composite cursors that are different -- renaming this one to reflect its specific purpose.
bikeshed did filter name for m2m queries
remove some prints
ManyToManyItem and set default "try-it": listitems
expand 0 comments
bad-example.com
submitted
#0
2 commits
expand
collapse
clean up dervive traits, specific cursor name
the derives came in from base64 in tangled#7, whic was removed.
the cursor is a composite, but we might have other composite cursors that are different -- renaming this one to reflect its specific purpose.
bikeshed did filter name for m2m queries