graph, graphql, tests: Support specifying sort order in _logs queries

Author: fordN

graph/src/components/log_store/elasticsearch.rs

@@ -84,7 +84,7 @@ impl ElasticsearchLogStore {
             "from": query.skip,
             "size": query.first,
             "sort": [
-                { "timestamp": { "order": "desc" } }
+                { "timestamp": { "order": query.order_direction.as_str() } }
             ]
         })
     }

graph/src/components/log_store/loki.rs

@@ -55,9 +55,16 @@ impl LokiLogStore {
         from: &str,
         to: &str,
         limit: u32,
+        order_direction: super::OrderDirection,
     ) -> Result<Vec<LogEntry>, LogStoreError> {
         let url = format!("{}/loki/api/v1/query_range", self.endpoint);
 
+        // Map order direction to Loki's direction parameter
+        let direction = match order_direction {
+            super::OrderDirection::Desc => "backward", // Most recent first
+            super::OrderDirection::Asc => "forward",   // Oldest first
+        };
+
         let mut request = self
             .client
             .get(&url)
@@ -66,7 +73,7 @@ impl LokiLogStore {
                 ("start", from),
                 ("end", to),
                 ("limit", &limit.to_string()),
-                ("direction", "backward"), // Most recent first
+                ("direction", direction),
             ])
             .timeout(Duration::from_secs(10));
 
@@ -158,7 +165,9 @@ impl LogStore for LokiLogStore {
         // Execute query with limit + skip to handle pagination
         let limit = query.first + query.skip;
 
-        let mut entries = self.execute_query(&logql_query, from, to, limit).await?;
+        let mut entries = self
+            .execute_query(&logql_query, from, to, limit, query.order_direction)
+            .await?;
 
         // Apply skip/first pagination
         if query.skip > 0 {
@@ -239,6 +248,7 @@ mod tests {
             search: None,
             first: 100,
             skip: 0,
+            order_direction: crate::components::log_store::OrderDirection::Desc,
         };
 
         let logql = store.build_logql_query(&query);
@@ -256,6 +266,7 @@ mod tests {
             search: None,
             first: 100,
             skip: 0,
+            order_direction: crate::components::log_store::OrderDirection::Desc,
         };
 
         let logql = store.build_logql_query(&query);
@@ -273,6 +284,7 @@ mod tests {
             search: Some("transaction failed".to_string()),
             first: 100,
             skip: 0,
+            order_direction: crate::components::log_store::OrderDirection::Desc,
         };
 
         let logql = store.build_logql_query(&query);

graph/src/schema/api.rs

@@ -1371,6 +1371,18 @@ fn logs_field() -> s::Field {
                     default_value: Some(s::Value::Int(0.into())),
                     directives: vec![],
                 },
+                // orderDirection: OrderDirection (default desc)
+                s::InputValue {
+                    position: Pos::default(),
+                    description: Some(
+                        "Sort direction for results. Default: desc (newest first)."
+                        .to_string()
+                    ),
+                    name: String::from("orderDirection"),
+                    value_type: s::Type::NamedType(String::from("OrderDirection")),
+                    default_value: Some(s::Value::Enum(String::from("desc"))),
+                    directives: vec![],
+                },
             ],
             field_type: s::Type::NonNullType(Box::new(s::Type::ListType(Box::new(
                 s::Type::NonNullType(Box::new(s::Type::NamedType(String::from("_Log_")))),

graph/src/schema/logs.graphql

@@ -15,6 +15,16 @@ enum LogLevel {
   DEBUG
 }
 
+"""
+Sort direction for query results.
+"""
+enum OrderDirection {
+  "Ascending order (oldest first for timestamps)"
+  asc
+  "Descending order (newest first for timestamps)"
+  desc
+}
+
 """
 A log entry emitted by a subgraph during indexing.
 Logs can be generated by the subgraph's AssemblyScript code using the `log.*` functions.

graphql/src/store/logs.rs

@@ -63,6 +63,7 @@ pub fn build_log_query(
     let mut search = None;
     let mut first = 100;
     let mut skip = 0;
+    let mut order_direction = graph::components::log_store::OrderDirection::Desc;
 
     // Parse arguments
     for (name, value) in &field.arguments {
@@ -156,6 +157,17 @@ pub fn build_log_query(
                     skip = skip_u32;
                 }
             }
+            "orderDirection" => {
+                if let r::Value::Enum(order_str) = value {
+                    order_direction = order_str.parse().map_err(|e: String| {
+                        QueryExecutionError::InvalidArgumentError(
+                            field.position,
+                            "orderDirection".to_string(),
+                            q::Value::String(e),
+                        )
+                    })?;
+                }
+            }
             _ => {
                 // Unknown argument, ignore
             }
@@ -170,5 +182,6 @@ pub fn build_log_query(
         search,
         first,
         skip,
+        order_direction,
     })
 }

tests/tests/integration_tests.rs

@@ -1578,6 +1578,64 @@ async fn test_logs_query(ctx: TestContext) -> anyhow::Result<()> {
         println!("✓ Field selection works correctly - only requested fields returned");
     }
 
+    // Test 8: Order direction - ascending
+    let query = r#"{
+            _logs(first: 10, orderDirection: asc) {
+                id
+                timestamp
+            }
+        }"#
+    .to_string();
+    let resp = subgraph.query(&query).await?;
+
+    let logs = resp["data"]["_logs"]
+        .as_array()
+        .context("Expected _logs to be an array")?;
+
+    // Verify ascending order (each timestamp >= previous)
+    if logs.len() > 1 {
+        for i in 1..logs.len() {
+            let prev_ts = logs[i - 1]["timestamp"].as_str().unwrap();
+            let curr_ts = logs[i]["timestamp"].as_str().unwrap();
+            assert!(
+                curr_ts >= prev_ts,
+                "Expected ascending order, but {} came before {}",
+                prev_ts,
+                curr_ts
+            );
+        }
+        println!("✓ Ascending order works correctly");
+    }
+
+    // Test 9: Order direction - descending (explicit)
+    let query = r#"{
+            _logs(first: 10, orderDirection: desc) {
+                id
+                timestamp
+            }
+        }"#
+    .to_string();
+    let resp = subgraph.query(&query).await?;
+
+    let logs = resp["data"]["_logs"]
+        .as_array()
+        .context("Expected _logs to be an array")?;
+
+    // Verify descending order (each timestamp <= previous)
+    if logs.len() > 1 {
+        for i in 1..logs.len() {
+            let prev_ts = logs[i - 1]["timestamp"].as_str().unwrap();
+            let curr_ts = logs[i]["timestamp"].as_str().unwrap();
+            assert!(
+                curr_ts <= prev_ts,
+                "Expected descending order, but {} came before {}",
+                prev_ts,
+                curr_ts
+            );
+        }
+        println!("✓ Descending order works correctly");
+    }
+
     Ok(())
 }