Explicitly specify the cursor type.

Author: ignatz

trailbase-core/src/admin/list_logs.rs

@@ -9,7 +9,7 @@ use serde::{Deserialize, Serialize};
 use std::borrow::Cow;
 use std::collections::HashMap;
 use trailbase_extension::geoip::{City, DatabaseType};
-use trailbase_qs::{Cursor, Order, OrderPrecedent, Query};
+use trailbase_qs::{Order, OrderPrecedent, Query};
 use ts_rs::TS;
 use uuid::Uuid;
 
@@ -174,16 +174,15 @@ pub async fn list_logs_handler(
     };
   }
 
-  let cursor = cursor.and_then(|c| match c {
-    Cursor::Integer(i) => Some(i),
-    Cursor::Blob(b) => {
-      log::warn!(
-        "expected integer cursor, got: {} from {raw_url_query:?}",
-        String::from_utf8_lossy(&b)
-      );
-      None
-    }
-  });
+  let cursor = if let Some(cursor) = cursor {
+    Some(
+      cursor
+        .parse::<i64>()
+        .map_err(|err| Error::BadRequest(err.into()))?,
+    )
+  } else {
+    None
+  };
 
   let geoip_db_type = trailbase_extension::geoip::database_type();
   let mut logs = fetch_logs(

trailbase-core/src/admin/rows/list_rows.rs

@@ -3,9 +3,9 @@ use log::*;
 use serde::Serialize;
 use std::borrow::Cow;
 use std::sync::Arc;
-use trailbase_qs::{Cursor, Order, OrderPrecedent, Query};
+use trailbase_qs::{Cursor, CursorType, Order, OrderPrecedent, Query};
 use trailbase_schema::QualifiedName;
-use trailbase_schema::sqlite::Column;
+use trailbase_schema::sqlite::{Column, ColumnDataType};
 use trailbase_sqlite::rows::rows_to_json_arrays;
 use ts_rs::TS;
 
@@ -93,6 +93,10 @@ pub async fn list_rows_handler(
   };
 
   let cursor_column = table_or_view_metadata.record_pk_column();
+  let cursor = match (cursor, cursor_column) {
+    (Some(cursor), Some((_idx, c))) => Some(parse_cursor(&cursor, &c)?),
+    _ => None,
+  };
   let (rows, columns) = fetch_rows(
     state.conn(),
     qualified_name,
@@ -235,6 +239,18 @@ async fn fetch_rows(
   ));
 }
 
+fn parse_cursor(cursor: &str, pk_col: &Column) -> Result<Cursor, Error> {
+  return match pk_col.data_type {
+    ColumnDataType::Blob => {
+      Cursor::parse(cursor, CursorType::Blob).map_err(|err| Error::BadRequest(err.into()))
+    }
+    ColumnDataType::Integer => {
+      Cursor::parse(cursor, CursorType::Integer).map_err(|err| Error::BadRequest(err.into()))
+    }
+    _ => Err(Error::BadRequest("Invalid cursor column type".into())),
+  };
+}
+
 #[cfg(test)]
 mod tests {
   use base64::prelude::*;

trailbase-core/src/admin/user/list_users.rs

@@ -104,7 +104,14 @@ pub async fn list_users_handler(
   let users = fetch_users(
     conn,
     filter_where_clause.clone(),
-    cursor,
+    if let Some(cursor) = cursor {
+      Some(
+        Cursor::parse(&cursor, trailbase_qs::CursorType::Blob)
+          .map_err(|err| Error::BadRequest(err.into()))?,
+      )
+    } else {
+      None
+    },
     order.as_ref().unwrap_or_else(|| &DEFAULT_ORDERING),
     limit_or_default(limit).map_err(|err| Error::BadRequest(err.into()))?,
   )

trailbase-core/src/records/list_records.rs

@@ -6,8 +6,9 @@ use axum::{
 use itertools::Itertools;
 use serde::Serialize;
 use std::borrow::Cow;
-use trailbase_qs::{Cursor, OrderPrecedent, Query};
-use trailbase_schema::QualifiedNameEscaped;
+use trailbase_qs::{Cursor, CursorType, OrderPrecedent, Query};
+use trailbase_schema::sqlite::Column;
+use trailbase_schema::{QualifiedNameEscaped, sqlite::ColumnDataType};
 use trailbase_sqlite::Value;
 
 use crate::app_state::AppState;
@@ -124,6 +125,8 @@ pub async fn list_records_handler(
   }
 
   let cursor_clause = if let Some(cursor) = cursor {
+    let cursor = parse_cursor(&cursor, pk_column)?;
+
     let mut pk_order = OrderPrecedent::Descending;
     if let Some(ref order) = order {
       if let Some((col, ord)) = order.columns.first() {
@@ -137,7 +140,10 @@ pub async fn list_records_handler(
       }
     }
 
-    params.push((Cow::Borrowed(":cursor"), cursor_to_value(cursor)));
+    params.push((
+      Cow::Borrowed(":cursor"),
+      crate::listing::cursor_to_value(cursor),
+    ));
     match pk_order {
       OrderPrecedent::Descending => Some(format!(r#"_ROW_."{}" < :cursor"#, pk_column.name)),
       OrderPrecedent::Ascending => Some(format!(r#"_ROW_."{}" > :cursor"#, pk_column.name)),
@@ -305,10 +311,13 @@ fn column_filter(col_name: &str) -> bool {
   return !col_name.starts_with("_");
 }
 
-fn cursor_to_value(cursor: Cursor) -> Value {
-  return match cursor {
-    Cursor::Integer(i) => Value::Integer(i),
-    Cursor::Blob(b) => Value::Blob(b),
+fn parse_cursor(cursor: &str, pk_col: &Column) -> Result<Cursor, RecordError> {
+  return match pk_col.data_type {
+    ColumnDataType::Blob => Cursor::parse(cursor, CursorType::Blob)
+      .map_err(|_| RecordError::BadRequest("Invalid blob cursor")),
+    ColumnDataType::Integer => Cursor::parse(cursor, CursorType::Integer)
+      .map_err(|_| RecordError::BadRequest("Invalid integer cursor")),
+    _ => Err(RecordError::BadRequest("Invalid cursor column type")),
   };
 }
 

trailbase-qs/src/lib.rs

@@ -9,5 +9,5 @@ mod util;
 mod value;
 
 pub use filter::{Combiner, ValueOrComposite};
-pub use query::{Cursor, Expand, Order, OrderPrecedent, Query};
+pub use query::{Cursor, CursorType, Expand, Order, OrderPrecedent, Query};
 pub use value::Value;

trailbase-qs/src/query.rs

@@ -6,6 +6,12 @@ use crate::util::deserialize_bool;
 
 pub type Error = serde_qs::Error;
 
+#[derive(Clone, Debug, PartialEq)]
+pub enum CursorType {
+  Blob,
+  Integer,
+}
+
 /// TrailBase supports cursors in a few formats:
 ///  * Integers
 ///  * Text-encoded UUIDs ([u8; 16])
@@ -19,42 +25,25 @@ pub enum Cursor {
   Integer(i64),
 }
 
-impl<'de> serde::de::Deserialize<'de> for Cursor {
-  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-  where
-    D: serde::de::Deserializer<'de>,
-  {
-    use serde::de::Error;
-    use serde_value::Value;
+impl Cursor {
+  pub fn parse(s: &str, cursor_type: CursorType) -> Result<Self, Error> {
+    return match cursor_type {
+      CursorType::Integer => {
+        let i = s.parse::<i64>().map_err(|err| Error::ParseInt(err))?;
+        Ok(Self::Integer(i))
+      }
+      CursorType::Blob => {
+        if let Ok(uuid) = uuid::Uuid::parse_str(&s) {
+          return Ok(Cursor::Blob(uuid.into()));
+        }
 
-    static EXPECTED: &str = "integer or url-safe base64 encoded byte cursor";
+        if let Ok(base64) = BASE64_URL_SAFE.decode(&s) {
+          return Ok(Cursor::Blob(base64));
+        }
 
-    let value = Value::deserialize(deserializer)?;
-    let Value::String(str) = value else {
-      return Err(Error::invalid_type(
-        crate::util::unexpected(&value),
-        &EXPECTED,
-      ));
+        Err(Error::Custom(format!("Failed to parse: {s}")))
+      }
     };
-
-    // FIXME: This is brittle. The consumer should explicitly define what kind of cursor we expect
-    // based on table schema.
-    if let Ok(integer) = str.parse::<i64>() {
-      return Ok(Cursor::Integer(integer));
-    }
-
-    if let Ok(uuid) = uuid::Uuid::parse_str(&str) {
-      return Ok(Cursor::Blob(uuid.into()));
-    }
-
-    if let Ok(base64) = BASE64_URL_SAFE.decode(&str) {
-      return Ok(Cursor::Blob(base64));
-    }
-
-    return Err(Error::invalid_type(
-      crate::util::unexpected(&Value::String(str)),
-      &EXPECTED,
-    ));
   }
 }
 
@@ -168,7 +157,7 @@ pub struct Query {
   /// Max number of elements returned per page.
   pub limit: Option<usize>,
   /// Cursor to page.
-  pub cursor: Option<Cursor>,
+  pub cursor: Option<String>,
   /// Offset to page. Cursor is more efficient when available
   pub offset: Option<usize>,
 
@@ -191,7 +180,7 @@ impl Query {
   pub fn parse(query: &str) -> Result<Query, Error> {
     // NOTE: We rely on non-strict mode to parse `filter[col0]=a&b%filter[col1]=c`.
     let qs = serde_qs::Config::new(9, false);
-    return qs.deserialize_str::<Query>(query);
+    return qs.deserialize_bytes::<Query>(query.as_bytes());
   }
 }
 
@@ -439,27 +428,33 @@ mod tests {
     assert_eq!(
       qs.deserialize_str::<Query>("cursor=-5").unwrap(),
       Query {
-        cursor: Some(Cursor::Integer(-5)),
+        cursor: Some("-5".to_string()),
         ..Default::default()
       }
     );
 
     let uuid = uuid::Uuid::now_v7();
+    let r = qs
+      .deserialize_str::<Query>(&format!("cursor={}", uuid.to_string()))
+      .unwrap();
     assert_eq!(
-      qs.deserialize_str::<Query>(&format!("cursor={}", uuid.to_string()))
-        .unwrap(),
+      r,
       Query {
-        cursor: Some(Cursor::Blob(uuid.as_bytes().into())),
+        cursor: Some(uuid.to_string()),
         ..Default::default()
       }
     );
+    assert_eq!(
+      Cursor::parse(&r.cursor.unwrap(), CursorType::Blob).unwrap(),
+      Cursor::Blob(uuid.into())
+    );
 
     let blob = BASE64_URL_SAFE.encode(uuid.as_bytes());
     assert_eq!(
       qs.deserialize_str::<Query>(&format!("cursor={blob}"))
         .unwrap(),
       Query {
-        cursor: Some(Cursor::Blob(uuid.as_bytes().into())),
+        cursor: Some(blob),
         ..Default::default()
       }
     );