Add reverse ordering support to link query endpoints

- Add "reverse" boolean parameter to three endpoints:
1. getManyToManyCounts (grouped counts)
2. getBacklinks (links to subject)
3. links (target links)

- Implement reverse iteration logic in both storage backends (mem_store
and rocks_store) for __reverse-chronological__ ordering

- Update HTML templates with (reverse) checkboxes

constellation/src/server/mod.rs

···
     /// Set the max number of links to return per page of results
     #[serde(default = "get_default_cursor_limit")]
     limit: u64,
+    /// Allow returning links in reverse order (default: false)
+    #[serde(default)]
+    reverse: bool,
 }
 #[derive(Serialize)]
 struct OtherSubjectCount {
···
             collection,
             &path,
             &path_to_other,
+            query.reverse,
             limit,
             cursor_key,
             &filter_dids,
···
     /// Set the max number of links to return per page of results
     #[serde(default = "get_default_cursor_limit")]
     limit: u64,
-    // TODO: allow reverse (er, forward) order as well
+    /// Allow returning links in reverse order (default: false)
+    #[serde(default)]
+    reverse: bool,
 }
 #[derive(Template, Serialize)]
 #[template(path = "get-backlinks.html.j2")]
···
             &query.subject,
             collection,
             &path,
+            query.reverse,
             limit,
             until,
             &filter_dids,
···
     from_dids: Option<String>, // comma separated: gross
     #[serde(default = "get_default_cursor_limit")]
     limit: u64,
-    // TODO: allow reverse (er, forward) order as well
+    /// Allow returning links in reverse order (default: false)
+    #[serde(default)]
+    reverse: bool,
 }
 #[derive(Template, Serialize)]
 #[template(path = "links.html.j2")]
···
             &query.target,
             &query.collection,
             &query.path,
+            query.reverse,
             limit,
             until,
             &filter_dids,
···
     path: String,
     cursor: Option<OpaqueApiCursor>,
     limit: Option<u64>,
-    // TODO: allow reverse (er, forward) order as well
 }
 #[derive(Template, Serialize)]
 #[template(path = "dids.html.j2")]

constellation/src/storage/mem_store.rs

···
         collection: &str,
         path: &str,
         path_to_other: &str,
+        reverse: bool,
         limit: u64,
         after: Option<String>,
         filter_dids: &HashSet<Did>,
···
         let filter_to_targets: HashSet<Target> =
             HashSet::from_iter(filter_to_targets.iter().map(|s| Target::new(s)));
 
-        let mut grouped_counts: HashMap<Target, (u64, HashSet<Did>)> = HashMap::new();
-        for (did, rkey) in linkers.iter().flatten().cloned() {
+        // the last type field here acts as an index to allow keeping track of the order in which
+        // we encountred single elements
+        let mut grouped_counts: HashMap<Target, (u64, HashSet<Did>, usize)> = HashMap::new();
+        for (idx, (did, rkey)) in linkers.iter().flatten().cloned().enumerate() {
             if !filter_dids.is_empty() && !filter_dids.contains(&did) {
                 continue;
             }
···
                 .take(1)
                 .next()
             {
-                let e = grouped_counts.entry(fwd_target.clone()).or_default();
+                let e =
+                    grouped_counts
+                        .entry(fwd_target.clone())
+                        .or_insert((0, HashSet::new(), idx));
                 e.0 += 1;
                 e.1.insert(did.clone());
             }
         }
         let mut items: Vec<(String, u64, u64)> = grouped_counts
             .iter()
-            .map(|(k, (n, u))| (k.0.clone(), *n, u.len() as u64))
+            .map(|(k, (n, u, _))| (k.0.clone(), *n, u.len() as u64))
             .collect();
-        items.sort();
+        // sort in reverse order to show entries from oldest to newest
+        if reverse {
+            items.sort_by(|a, b| b.cmp(a));
+        } else {
+            items.sort();
+        }
         items = items
             .into_iter()
             .skip_while(|(t, _, _)| after.as_ref().map(|a| t <= a).unwrap_or(false))
···
         target: &str,
         collection: &str,
         path: &str,
+        reverse: bool,
         limit: u64,
         until: Option<u64>,
         filter_dids: &HashSet<Did>,
···
             });
         };
 
-        let did_rkeys: Vec<_> = if !filter_dids.is_empty() {
+        let mut did_rkeys: Vec<_> = if !filter_dids.is_empty() {
             did_rkeys
                 .iter()
                 .filter(|m| {
···
 
         let alive = did_rkeys.iter().flatten().count();
         let gone = total - alive;
+
+        if reverse {
+            did_rkeys.reverse();
+        }
 
         let items: Vec<_> = did_rkeys[begin..end]
             .iter()

constellation/src/storage/mod.rs

···
         collection: &str,
         path: &str,
         path_to_other: &str,
+        reverse: bool,
         limit: u64,
         after: Option<String>,
         filter_dids: &HashSet<Did>,
···
         target: &str,
         collection: &str,
         path: &str,
+        reverse: bool,
         limit: u64,
         until: Option<u64>,
         filter_dids: &HashSet<Did>,

constellation/src/storage/rocks_store.rs

···
         collection: &str,
         path: &str,
         path_to_other: &str,
+        reverse: bool,
         limit: u64,
         after: Option<String>,
         filter_dids: &HashSet<Did>,
···
         }
 
         let mut items: Vec<(String, u64, u64)> = Vec::with_capacity(grouped_counts.len());
+
         for (target_id, (n, dids)) in &grouped_counts {
             let Some(target) = self
                 .target_id_table
···
                 continue;
             };
             items.push((target.0 .0, *n, dids.len() as u64));
+        }
+
+        // Sort in desired direction
+        if reverse {
+            items.sort_by(|a, b| b.cmp(a)); // descending
+        } else {
+            items.sort(); // ascending
         }
 
         let next = if grouped_counts.len() as u64 >= limit {
···
         target: &str,
         collection: &str,
         path: &str,
+        reverse: bool,
         limit: u64,
         until: Option<u64>,
         filter_dids: &HashSet<Did>,
···
         let begin = end.saturating_sub(limit as usize);
         let next = if begin == 0 { None } else { Some(begin as u64) };
 
-        let did_id_rkeys = linkers.0[begin..end].iter().rev().collect::<Vec<_>>();
+        let mut did_id_rkeys = linkers.0[begin..end].iter().rev().collect::<Vec<_>>();
+
+        if reverse {
+            did_id_rkeys.reverse();
+        }
 
         let mut items = Vec::with_capacity(did_id_rkeys.len());
         // TODO: use get-many (or multi-get or whatever it's called)

constellation/templates/base.html.j2

···
         padding: 0.5em 0.3em;
         max-width: 100%;
       }
+	  pre.code input {
+		  margin: 0;
+		  padding: 0;
+	  }
       .stat {
         color: #f90;
         font-size: 1.618rem;

constellation/templates/get-backlinks.html.j2

···
 
 {% block content %}
 
-  {% call try_it::get_backlinks(query.subject, query.source, query.did, query.limit) %}
+  {% call try_it::get_backlinks(query.subject, query.source, query.did, query.limit, query.reverse) %}
 
   <h2>
     Links to <code>{{ query.subject }}</code>
···
         <input type="hidden" name="did" value="{{ did }}" />
       {% endfor %}
       <input type="hidden" name="cursor" value={{ c|json|safe }} />
+      <input type="hidden" name="reverse" value="{{ query.reverse }}">
       <button type="submit">next page&hellip;</button>
     </form>
   {% else %}

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

···
     query.did,
     query.other_subject,
     query.limit,
+    query.reverse,
   ) %}
 
   <h2>
···
       {% endfor %}
       <input type="hidden" name="limit" value="{{ query.limit }}" />
       <input type="hidden" name="cursor" value={{ c|json|safe }} />
+      <input type="hidden" name="reverse" value="{{ query.reverse }}">
       <button type="submit">next page&hellip;</button>
     </form>
   {% else %}

constellation/templates/hello.html.j2

···
     <li><p><code>source</code>: required. Example: <code>app.bsky.feed.like:subject.uri</code></p></li>
     <li><p><code>did</code>: optional, filter links to those from specific users. Include multiple times to filter by multiple users. Example: <code>did=did:plc:vc7f4oafdgxsihk4cry2xpze&did=did:plc:vc7f4oafdgxsihk4cry2xpze</code></p></li>
     <li><p><code>limit</code>: optional. Default: <code>16</code>. Maximum: <code>100</code></p></li>
+    <li><p><code>reverse</code>: optional, return links in reverse order. Default: <code>false</code></p></li>
   </ul>
 
   <p style="margin-bottom: 0"><strong>Try it:</strong></p>
-  {% call try_it::get_backlinks("at://did:plc:a4pqq234yw7fqbddawjo7y35/app.bsky.feed.post/3m237ilwc372e", "app.bsky.feed.like:subject.uri", [""], 16) %}
+  {% call
+  try_it::get_backlinks("at://did:plc:a4pqq234yw7fqbddawjo7y35/app.bsky.feed.post/3m237ilwc372e", "app.bsky.feed.like:subject.uri", [""], 16, false) %}
 
 
   <h3 class="route"><code>GET /xrpc/blue.microcosm.links.getManyToManyCounts</code></h3>
···
     <li><p><code>did</code>: optional, filter links to those from specific users. Include multiple times to filter by multiple users. Example: <code>did=did:plc:vc7f4oafdgxsihk4cry2xpze&did=did:plc:vc7f4oafdgxsihk4cry2xpze</code></p></li>
     <li><p><code>otherSubject</code>: optional, filter secondary links to specific subjects. Include multiple times to filter by multiple users. Example: <code>at://did:plc:vc7f4oafdgxsihk4cry2xpze/app.bsky.feed.post/3lgwdn7vd722r</code></p></li>
     <li><p><code>limit</code>: optional. Default: <code>16</code>. Maximum: <code>100</code></p></li>
+    <li><p><code>reverse</code>: optional, return links in reverse order. Default: <code>false</code></p></li>
   </ul>
 
   <p style="margin-bottom: 0"><strong>Try it:</strong></p>
···
     [""],
     [""],
     25,
+    false,
   ) %}
 
 
···
     <li><p><code>did</code>: optional, filter links to those from specific users. Include multiple times to filter by multiple users. Example: <code>did=did:plc:vc7f4oafdgxsihk4cry2xpze&did=did:plc:vc7f4oafdgxsihk4cry2xpze</code></p></li>
     <li><p><code>from_dids</code> [deprecated]: optional. Use <code>did</code> instead. Example: <code>from_dids=did:plc:vc7f4oafdgxsihk4cry2xpze,did:plc:vc7f4oafdgxsihk4cry2xpze</code></p></li>
     <li><p><code>limit</code>: optional. Default: <code>16</code>. Maximum: <code>100</code></p></li>
+    <li><p><code>reverse</code>: optional, return links in reverse order. Default: <code>false</code></p></li>
   </ul>
 
   <p style="margin-bottom: 0"><strong>Try it:</strong></p>
-  {% call try_it::links("at://did:plc:a4pqq234yw7fqbddawjo7y35/app.bsky.feed.post/3m237ilwc372e", "app.bsky.feed.like", ".subject.uri", [""], 16) %}
+  {% call try_it::links("at://did:plc:a4pqq234yw7fqbddawjo7y35/app.bsky.feed.post/3m237ilwc372e", "app.bsky.feed.like", ".subject.uri", [""], 16, false) %}
 
 
   <h3 class="route"><code>GET /links/distinct-dids</code></h3>

constellation/templates/links.html.j2

···
 
 {% block content %}
 
-  {% call try_it::links(query.target, query.collection, query.path, query.did, query.limit) %}
+  {% call try_it::links(query.target, query.collection, query.path, query.did, query.limit, query.reverse) %}
 
   <h2>
     Links to <code>{{ query.target }}</code>
···
       <input type="hidden" name="collection" value="{{ query.collection }}" />
       <input type="hidden" name="path" value="{{ query.path }}" />
       <input type="hidden" name="cursor" value={{ c|json|safe }} />
+      <input type="hidden" name="reverse" value="{{ query.reverse }}">
       <button type="submit">next page&hellip;</button>
     </form>
   {% else %}

constellation/templates/try-it-macros.html.j2

···
-{% macro get_backlinks(subject, source, dids, limit) %}
+{% macro get_backlinks(subject, source, dids, limit, reverse) %}
   <form method="get" action="/xrpc/blue.microcosm.links.getBacklinks">
     <pre class="code"><strong>GET</strong> /xrpc/blue.microcosm.links.getBacklinks
   ?subject=    <input type="text" name="subject" value="{{ subject }}" placeholder="at-uri, did, uri..." />
···
   {%- for did in dids %}{% if !did.is_empty() %}
   &did=        <input type="text" name="did" value="{{ did }}" placeholder="did:plc:..." />{% endif %}{% endfor %}
   <span id="did-placeholder"></span>             <button id="add-did">+ did filter</button>
-  &limit=      <input type="number" name="limit" value="{{ limit }}" max="100" placeholder="100" /> <button type="submit">get links</button></pre>
+  &limit=      <input type="number" name="limit" value="{{ limit }}" max="100" placeholder="100" />
+  &reverse=    <input type="checkbox" name="reverse" value="true" checked="false"><button type="submit">get links</button></pre>
   </form>
   <script>
     const addDidButton = document.getElementById('add-did');
···
   </script>
 {% endmacro %}
 
-{% macro get_many_to_many_counts(subject, source, pathToOther, dids, otherSubjects, limit) %}
+{% macro get_many_to_many_counts(subject, source, pathToOther, dids, otherSubjects, limit, reverse) %}
   <form method="get" action="/xrpc/blue.microcosm.links.getManyToManyCounts">
     <pre class="code"><strong>GET</strong> /xrpc/blue.microcosm.links.getManyToManyCounts
   ?subject=      <input type="text" name="subject" value="{{ subject }}" placeholder="at-uri, did, uri..." />
···
   {%- for otherSubject in otherSubjects %}{% if !otherSubject.is_empty() %}
   &otherSubject= <input type="text" name="did" value="{{ otherSubject }}" placeholder="at-uri, did, uri..." />{% endif %}{% endfor %}
   <span id="m2m-did-placeholder"></span>               <button id="m2m-add-did">+ did filter</button>
-  &limit=        <input type="number" name="limit" value="{{ limit }}" max="100" placeholder="100" /> <button type="submit">get links</button></pre>
+  &limit=        <input type="number" name="limit" value="{{ limit }}" max="100" placeholder="100" />
+  &reverse=      <input type="checkbox" name="reverse" value="true" checked="false"><button type="submit">get links</button></pre>
   </form>
   <script>
     const m2mAddDidButton = document.getElementById('m2m-add-did');
···
   </script>
 {% endmacro %}
 
-{% macro links(target, collection, path, dids, limit) %}
+{% macro links(target, collection, path, dids, limit, reverse) %}
   <form method="get" action="/links">
     <pre class="code"><strong>GET</strong> /links
   ?target=     <input type="text" name="target" value="{{ target }}" placeholder="target" />
···
   {%- for did in dids %}{% if !did.is_empty() %}
   &did=        <input type="text" name="did" value="{{ did }}" placeholder="did:plc:..." />{% endif %}{% endfor %}
   <span id="did-placeholder"></span>             <button id="add-did">+ did filter</button>
-  &limit=      <input type="number" name="limit" value="{{ limit }}" max="100" placeholder="100" /> <button type="submit">get links</button></pre>
+  &limit=      <input type="number" name="limit" value="{{ limit }}" max="100" placeholder="100" />
+  &reverse=	   <input type="checkbox" name="reverse" value="true" checked="false">
+  <button type="submit">get links</button></pre>
   </form>
   <script>
     const addDidButton = document.getElementById('add-did');