Replace boolean reverse parameter with Order enum

Refactor link query APIs to use an explicit Order enum
(OldestToNewest, NewestToOldest) instead of a boolean
reverse flag for better clarity and maintainability.

constellation/src/server/mod.rs

···
 use tokio::task::spawn_blocking;
 use tokio_util::sync::CancellationToken;
 
-use crate::storage::{LinkReader, StorageStats};
+use crate::storage::{LinkReader, Order, StorageStats};
 use crate::{CountsByCount, Did, RecordId};
 
 mod acceptable;
···
 
     let path_to_other = format!(".{}", query.path_to_other);
 
+    let order = if query.reverse {
+        Order::OldestToNewest
+    } else {
+        Order::NewestToOldest
+    };
+
     let paged = store
         .get_many_to_many_counts(
             &query.subject,
             collection,
             &path,
             &path_to_other,
-            query.reverse,
+            order,
             limit,
             cursor_key,
             &filter_dids,
···
     };
     let path = format!(".{path}");
 
+    let order = if query.reverse {
+        Order::OldestToNewest
+    } else {
+        Order::NewestToOldest
+    };
+
     let paged = store
         .get_links(
             &query.subject,
             collection,
             &path,
-            query.reverse,
+            order,
             limit,
             until,
             &filter_dids,
···
         }
     }
 
+    let order = if query.reverse {
+        Order::OldestToNewest
+    } else {
+        Order::NewestToOldest
+    };
+
     let paged = store
         .get_links(
             &query.target,
             &query.collection,
             &query.path,
-            query.reverse,
+            order,
             limit,
             until,
             &filter_dids,

constellation/src/storage/mem_store.rs

···
 use super::{
-    LinkReader, LinkStorage, PagedAppendingCollection, PagedOrderedCollection, StorageStats,
+    LinkReader, LinkStorage, Order, PagedAppendingCollection, PagedOrderedCollection,
+    StorageStats,
 };
 use crate::{ActionableEvent, CountsByCount, Did, RecordId};
 use anyhow::Result;
···
         collection: &str,
         path: &str,
         path_to_other: &str,
-        reverse: bool,
+        order: Order,
         limit: u64,
         after: Option<String>,
         filter_dids: &HashSet<Did>,
···
             .iter()
             .map(|(k, (n, u, _))| (k.0.clone(), *n, u.len() as u64))
             .collect();
-        // sort in reverse order to show entries from oldest to newest
-        if reverse {
-            items.sort_by(|a, b| b.cmp(a));
-        } else {
-            items.sort();
+        // Sort based on order: OldestToNewest uses descending order, NewestToOldest uses ascending
+        match order {
+            Order::OldestToNewest => items.sort_by(|a, b| b.cmp(a)),
+            Order::NewestToOldest => items.sort(),
         }
         items = items
             .into_iter()
···
         target: &str,
         collection: &str,
         path: &str,
-        reverse: bool,
+        order: Order,
         limit: u64,
         until: Option<u64>,
         filter_dids: &HashSet<Did>,
···
         let end: usize;
         let next: Option<u64>;
 
-        if reverse {
-            begin = until.map(|u| (u) as usize).unwrap_or(0);
-            end = std::cmp::min(begin + limit as usize, total);
+        match order {
+            // OldestToNewest: start from the beginning, paginate forward
+            Order::OldestToNewest => {
+                begin = until.map(|u| (u) as usize).unwrap_or(0);
+                end = std::cmp::min(begin + limit as usize, total);
 
-            next = if end < total {
-                Some(end as u64 + 1)
-            } else {
-                None
-            };
-        } else {
-            end = until
-                .map(|u| std::cmp::min(u as usize, total))
-                .unwrap_or(total);
-            begin = end.saturating_sub(limit as usize);
-            next = if begin == 0 { None } else { Some(begin as u64) };
+                next = if end < total {
+                    Some(end as u64 + 1)
+                } else {
+                    None
+                };
+            }
+            // NewestToOldest: start from the end, paginate backward
+            Order::NewestToOldest => {
+                end = until
+                    .map(|u| std::cmp::min(u as usize, total))
+                    .unwrap_or(total);
+                begin = end.saturating_sub(limit as usize);
+                next = if begin == 0 { None } else { Some(begin as u64) };
+            }
         }
 
         let alive = did_rkeys.iter().flatten().count();
···
             })
             .collect();
 
-        if reverse {
+        // For OldestToNewest, reverse the items to maintain forward chronological order
+        if order == Order::OldestToNewest {
             items.reverse();
         }
 

constellation/src/storage/mod.rs

···
 #[cfg(feature = "rocks")]
 pub use rocks_store::RocksStorage;
 
+/// Ordering for paginated link queries
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Order {
+    /// Newest links first (default)
+    NewestToOldest,
+    /// Oldest links first
+    OldestToNewest,
+}
+
 #[derive(Debug, PartialEq)]
 pub struct PagedAppendingCollection<T> {
     pub version: (u64, u64), // (collection length, deleted item count) // TODO: change to (total, active)? since dedups isn't "deleted"
···
         collection: &str,
         path: &str,
         path_to_other: &str,
-        reverse: bool,
+        order: Order,
         limit: u64,
         after: Option<String>,
         filter_dids: &HashSet<Did>,
···
         target: &str,
         collection: &str,
         path: &str,
-        reverse: bool,
+        order: Order,
         limit: u64,
         until: Option<u64>,
         filter_dids: &HashSet<Did>,
···
                 "a.com",
                 "app.t.c",
                 ".abc.uri",
-                false,
+                Order::NewestToOldest,
                 100,
                 None,
                 &HashSet::default()
···
                 "a.com",
                 "app.t.c",
                 ".abc.uri",
-                false,
+                Order::NewestToOldest,
                 100,
                 None,
                 &HashSet::default()
···
             "a.com",
             "app.t.c",
             ".abc.uri",
-            false,
+            Order::NewestToOldest,
             2,
             None,
             &HashSet::default(),
···
             "a.com",
             "app.t.c",
             ".abc.uri",
-            false,
+            Order::NewestToOldest,
             2,
             links.next,
             &HashSet::default(),
···
             "a.com",
             "app.t.c",
             ".abc.uri",
-            false,
+            Order::NewestToOldest,
             2,
             links.next,
             &HashSet::default(),
···
             )?;
         }
 
-        // Test reverse: true (oldest first)
+        // Test OldestToNewest order (oldest first)
         let links = storage.get_links(
             "a.com",
             "app.t.c",
             ".abc.uri",
-            true,
+            Order::OldestToNewest,
             2,
             None,
             &HashSet::default(),
···
                 total: 5,
             }
         );
-        // Test reverse: false (newest first)
+        // Test NewestToOldest order (newest first)
         let links = storage.get_links(
             "a.com",
             "app.t.c",
             ".abc.uri",
-            false,
+            Order::NewestToOldest,
             2,
             None,
             &HashSet::default(),
···
             "a.com",
             "app.t.c",
             ".abc.uri",
-            false,
+            Order::NewestToOldest,
             2,
             None,
             &HashSet::from([Did("did:plc:linker".to_string())]),
···
             "a.com",
             "app.t.c",
             ".abc.uri",
-            false,
+            Order::NewestToOldest,
             2,
             None,
             &HashSet::from([Did("did:plc:linker".to_string())]),
···
             "a.com",
             "app.t.c",
             ".abc.uri",
-            false,
+            Order::NewestToOldest,
             2,
             None,
             &HashSet::from([Did("did:plc:someone-else".to_string())]),
···
             "a.com",
             "app.t.c",
             ".abc.uri",
-            false,
+            Order::NewestToOldest,
             2,
             None,
             &HashSet::from([Did("did:plc:linker".to_string())]),
···
             "a.com",
             "app.t.c",
             ".abc.uri",
-            false,
+            Order::NewestToOldest,
             2,
             None,
             &HashSet::from([
···
             "a.com",
             "app.t.c",
             ".abc.uri",
-            false,
+            Order::NewestToOldest,
             2,
             None,
             &HashSet::from([Did("did:plc:someone-unknown".to_string())]),
···
             "a.com",
             "app.t.c",
             ".abc.uri",
-            false,
+            Order::NewestToOldest,
             2,
             None,
             &HashSet::default(),
···
             "a.com",
             "app.t.c",
             ".abc.uri",
-            false,
+            Order::NewestToOldest,
             2,
             links.next,
             &HashSet::default(),
···
             "a.com",
             "app.t.c",
             ".abc.uri",
-            false,
+            Order::NewestToOldest,
             2,
             None,
             &HashSet::default(),
···
             "a.com",
             "app.t.c",
             ".abc.uri",
-            false,
+            Order::NewestToOldest,
             2,
             links.next,
             &HashSet::default(),
···
             "a.com",
             "app.t.c",
             ".abc.uri",
-            false,
+            Order::NewestToOldest,
             2,
             None,
             &HashSet::default(),
···
             "a.com",
             "app.t.c",
             ".abc.uri",
-            false,
+            Order::NewestToOldest,
             2,
             links.next,
             &HashSet::default(),
···
             "a.com",
             "app.t.c",
             ".abc.uri",
-            false,
+            Order::NewestToOldest,
             2,
             None,
             &HashSet::default(),
···
             "a.com",
             "app.t.c",
             ".abc.uri",
-            false,
+            Order::NewestToOldest,
             2,
             links.next,
             &HashSet::default(),
···
                 "a.b.c",
                 ".d.e",
                 ".f.g",
-                false,
+                Order::NewestToOldest,
                 10,
                 None,
                 &HashSet::new(),
···
                 "app.t.c",
                 ".abc.uri",
                 ".def.uri",
-                false,
+                Order::NewestToOldest,
                 10,
                 None,
                 &HashSet::new(),
···
                 "app.t.c",
                 ".abc.uri",
                 ".def.uri",
-                false,
+                Order::NewestToOldest,
                 10,
                 None,
                 &HashSet::new(),
···
                 "app.t.c",
                 ".abc.uri",
                 ".def.uri",
-                false,
+                Order::NewestToOldest,
                 10,
                 None,
                 &HashSet::from_iter([Did("did:plc:fdsa".to_string())]),
···
                 "app.t.c",
                 ".abc.uri",
                 ".def.uri",
-                false,
+                Order::NewestToOldest,
                 10,
                 None,
                 &HashSet::new(),
···
             2,
         )?;
 
-        // Test reverse: false (default order - by target ascending)
+        // Test NewestToOldest order (default order - by target ascending)
         let counts = storage.get_many_to_many_counts(
             "a.com",
             "app.t.c",
             ".abc.uri",
             ".def.uri",
-            false,
+            Order::NewestToOldest,
             10,
             None,
             &HashSet::new(),
···
         assert_eq!(counts.items[1].0, "c.com");
         assert_eq!(counts.items[2].0, "d.com");
 
-        // Test reverse: true (descending order - by target descending)
+        // Test OldestToNewest order (descending order - by target descending)
         let counts = storage.get_many_to_many_counts(
             "a.com",
             "app.t.c",
             ".abc.uri",
             ".def.uri",
-            true,
+            Order::OldestToNewest,
             10,
             None,
             &HashSet::new(),

constellation/src/storage/rocks_store.rs

···
 use super::{
-    ActionableEvent, LinkReader, LinkStorage, PagedAppendingCollection, PagedOrderedCollection,
-    StorageStats,
+    ActionableEvent, LinkReader, LinkStorage, Order, PagedAppendingCollection,
+    PagedOrderedCollection, StorageStats,
 };
 use crate::{CountsByCount, Did, RecordId};
 use anyhow::{bail, Result};
···
         collection: &str,
         path: &str,
         path_to_other: &str,
-        reverse: bool,
+        order: Order,
         limit: u64,
         after: Option<String>,
         filter_dids: &HashSet<Did>,
···
             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
+        // Sort based on order: OldestToNewest uses descending order, NewestToOldest uses ascending
+        match order {
+            Order::OldestToNewest => items.sort_by(|a, b| b.cmp(a)), // descending
+            Order::NewestToOldest => items.sort(),                    // ascending
         }
 
         let next = if grouped_counts.len() as u64 >= limit {
···
         target: &str,
         collection: &str,
         path: &str,
-        reverse: bool,
+        order: Order,
         limit: u64,
         until: Option<u64>,
         filter_dids: &HashSet<Did>,
···
         let begin: usize;
         let next: Option<u64>;
 
-        if reverse {
-            begin = until.map(|u| (u - 1) as usize).unwrap_or(0);
-            end = std::cmp::min(begin + limit as usize, total as usize);
+        match order {
+            // OldestToNewest: start from the beginning, paginate forward
+            Order::OldestToNewest => {
+                begin = until.map(|u| (u - 1) as usize).unwrap_or(0);
+                end = std::cmp::min(begin + limit as usize, total as usize);
 
-            next = if end < total as usize {
-                Some(end as u64 + 1)
-            } else {
-                None
+                next = if end < total as usize {
+                    Some(end as u64 + 1)
+                } else {
+                    None
+                }
             }
-        } else {
-            end = until.map(|u| std::cmp::min(u, total)).unwrap_or(total) as usize;
-            begin = end.saturating_sub(limit as usize);
-            next = if begin == 0 { None } else { Some(begin as u64) };
+            // NewestToOldest: start from the end, paginate backward
+            Order::NewestToOldest => {
+                end = until.map(|u| std::cmp::min(u, total)).unwrap_or(total) as usize;
+                begin = end.saturating_sub(limit as usize);
+                next = if begin == 0 { None } else { Some(begin as u64) };
+            }
         }
 
         let mut did_id_rkeys = linkers.0[begin..end].iter().rev().collect::<Vec<_>>();
 
-        if reverse {
+        // For OldestToNewest, reverse the items to maintain forward chronological order
+        if order == Order::OldestToNewest {
             did_id_rkeys.reverse();
         }