Add GET /snippets route

We already have `POST /snippets` route that creates new snippets, but we
were missing `GET /snippets` route to list recently created snippets.
This patch implements missing route.

Co-Authored-By: Roman Podoliaka <[email protected]>

Author: ikalnytskyi

Cargo.lock

@@ -24,13 +24,14 @@ diesel = { version = "1.4.5", features = ["chrono", "postgres", "r2d2"] }
 jsonwebtoken = "7.2.0"
 rand = "0.7.3"
 reqwest = { version = "0.11.2", features = ["blocking", "json"] }
-rocket = "0.4.5"
-rocket_contrib = {version = "0.4.5", features = ["json"]}
+rocket = "0.4.10"
+rocket_contrib = {version = "0.4.10", features = ["json"]}
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 tracing = "0.1.25"
 tracing-subscriber = "0.2.16"
 uuid = { version = "0.8.2", features = ["v4"] }
+percent-encoding = "2.1.0"
 
 [dev-dependencies]
 tempfile = "3.2.0"

Cargo.toml

@@ -68,6 +68,7 @@ pub fn create_app() -> Result<rocket::Rocket, Box<dyn Error>> {
 
     let routes = routes![
         routes::snippets::create_snippet,
+        routes::snippets::list_snippets,
         routes::snippets::get_snippet,
         routes::syntaxes::get_syntaxes,
         routes::snippets::import_snippet,

src/application.rs

@@ -32,13 +32,13 @@ impl ApiError {
     /// Reason why the request failed.
     pub fn reason(&self) -> &str {
         match self {
-            ApiError::BadRequest(msg) => &msg,
-            ApiError::Forbidden(msg) => &msg,
-            ApiError::NotAcceptable(msg) => &msg,
-            ApiError::Conflict(msg) => &msg,
-            ApiError::NotFound(msg) => &msg,
-            ApiError::InternalError(msg) => &msg,
-            ApiError::UnsupportedMediaType(msg) => &msg,
+            ApiError::BadRequest(msg) => msg,
+            ApiError::Forbidden(msg) => msg,
+            ApiError::NotAcceptable(msg) => msg,
+            ApiError::Conflict(msg) => msg,
+            ApiError::NotFound(msg) => msg,
+            ApiError::InternalError(msg) => msg,
+            ApiError::UnsupportedMediaType(msg) => msg,
         }
     }
 

src/errors.rs

@@ -1,14 +1,18 @@
 use std::convert::TryFrom;
 
+use percent_encoding::{utf8_percent_encode, AsciiSet, CONTROLS};
 use rocket::http::uri::Origin;
+use rocket::http::{HeaderMap, RawStr};
 use rocket::response::status::Created;
 use rocket::State;
 use serde::Deserialize;
 
 use crate::application::Config;
 use crate::errors::ApiError;
-use crate::storage::{Changeset, DateTime, Snippet, Storage};
-use crate::web::{BearerAuth, Input, NegotiatedContentType, Output};
+use crate::storage::{Changeset, DateTime, Direction, ListSnippetsQuery, Snippet, Storage};
+use crate::web::{
+    BearerAuth, Input, NegotiatedContentType, Output, PaginationLimit, WithHttpHeaders,
+};
 
 fn create_snippet_impl(
     storage: &dyn Storage,
@@ -21,6 +25,68 @@ fn create_snippet_impl(
     Ok(Created(location, Some(Output(new_snippet))))
 }
 
+fn create_link_header(
+    origin: &Origin,
+    next_marker: Option<String>,
+    prev_marker: Option<String>,
+    prev_needed: bool,
+) -> String {
+    const QUERY_ENCODE_SET: &AsciiSet = &CONTROLS
+        .add(b' ')
+        .add(b'"')
+        .add(b'#')
+        .add(b'<')
+        .add(b'>')
+        .add(b'&');
+
+    let query_wo_marker = origin.query().map(|q| {
+        q.split('&')
+            .filter_map(|v| {
+                let v = RawStr::from_str(v).percent_decode_lossy();
+                if !v.starts_with("marker=") {
+                    Some(utf8_percent_encode(&v, QUERY_ENCODE_SET).to_string())
+                } else {
+                    None
+                }
+            })
+            .collect::<Vec<_>>()
+            .join("&")
+    });
+    let query_first = query_wo_marker.clone();
+    let mut query_next = next_marker.map(|marker| format!("marker={}", marker));
+    let mut query_prev = prev_marker.map(|marker| format!("marker={}", marker));
+
+    // If a request URL does contain query parameters (other than marker), we
+    // must reuse them together with next/prev markers.
+    if let Some(query_wo_marker) = query_wo_marker {
+        query_next = query_next.map(|query| format!("{}&{}", query_wo_marker, query));
+        query_prev = query_prev.map(|query| format!("{}&{}", query_wo_marker, query));
+    }
+
+    // If a previous page is the first page, we don't have 'prev_marker' set
+    // yet the link must be generated. If that's the case, reuse query
+    // parameters we are using to generate a link to the first page.
+    if query_prev.is_none() && prev_needed {
+        query_prev = query_first.clone();
+    }
+
+    vec![
+        // (query string, rel, is_required)
+        (&query_first, "first", true),
+        (&query_next, "next", query_next.is_some()),
+        (&query_prev, "prev", prev_needed),
+    ]
+    .into_iter()
+    .filter(|item| item.2)
+    .map(|item| match item.0 {
+        Some(query) => (vec![origin.path(), query.as_str()].join("?"), item.1),
+        None => (origin.path().to_owned(), item.1),
+    })
+    .map(|item| format!("<{}>; rel=\"{}\"", item.0, item.1))
+    .collect::<Vec<_>>()
+    .join(", ")
+}
+
 #[derive(Deserialize)]
 #[serde(deny_unknown_fields)]
 pub struct NewSnippet {
@@ -77,6 +143,68 @@ pub fn create_snippet(
     create_snippet_impl(&**storage, &snippet, origin.path())
 }
 
+fn split_marker(mut snippets: Vec<Snippet>, limit: usize) -> (Option<String>, Vec<Snippet>) {
+    if snippets.len() > limit {
+        snippets.truncate(limit);
+        (snippets.last().map(|m| m.id.to_owned()), snippets)
+    } else {
+        (None, snippets)
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+#[get("/snippets?<title>&<syntax>&<tag>&<marker>&<limit>")]
+pub fn list_snippets<'o, 'h>(
+    storage: State<Box<dyn Storage>>,
+    origin: &'o Origin,
+    title: Option<String>,
+    syntax: Option<String>,
+    tag: Option<String>,
+    limit: Option<Result<PaginationLimit, ApiError>>,
+    marker: Option<String>,
+    _content_type: NegotiatedContentType,
+    _user: BearerAuth,
+) -> Result<WithHttpHeaders<'h, Output<Vec<Snippet>>>, ApiError> {
+    let mut criteria = ListSnippetsQuery {
+        title,
+        syntax,
+        tags: tag.map(|v| vec![v]),
+        ..Default::default()
+    };
+
+    // Fetch one more record in order to detect if there's a next page, and
+    // generate appropriate Link entry accordingly.
+    let limit = limit
+        .unwrap_or_else(|| Ok(<PaginationLimit as Default>::default()))?
+        .0;
+    criteria.pagination.limit = limit + 1;
+    criteria.pagination.marker = marker;
+
+    let snippets = storage.list(criteria.clone())?;
+    let mut prev_needed = false;
+    let (next_marker, snippets) = split_marker(snippets, limit);
+    let prev_marker = if criteria.pagination.marker.is_some() && !snippets.is_empty() {
+        // In order to generate Link entry for previous page we have no choice
+        // but to issue the query one more time into opposite direction.
+        criteria.pagination.direction = Direction::Asc;
+        criteria.pagination.marker = Some(snippets[0].id.to_owned());
+        let prev_snippets = storage.list(criteria)?;
+        prev_needed = !prev_snippets.is_empty();
+
+        prev_snippets.get(limit).map(|m| m.id.to_owned())
+    } else {
+        None
+    };
+
+    let mut headers_map = HeaderMap::new();
+    headers_map.add_raw(
+        "Link",
+        create_link_header(origin, next_marker, prev_marker, prev_needed),
+    );
+
+    Ok(WithHttpHeaders(headers_map, Some(Output(snippets))))
+}
+
 #[derive(Deserialize)]
 #[serde(deny_unknown_fields)]
 pub struct ImportSnippet {

src/routes/snippets.rs

@@ -3,7 +3,7 @@ mod models;
 mod sql;
 
 pub use errors::StorageError;
-pub use models::{Changeset, DateTime, Direction, ListSnippetsQuery, Snippet};
+pub use models::{Changeset, DateTime, Direction, ListSnippetsQuery, Pagination, Snippet};
 pub use sql::SqlStorage;
 
 /// CRUD interface for storing/loading snippets from a persistent storage.

src/storage/mod.rs

@@ -3,7 +3,6 @@ use std::iter;
 use rand::Rng;
 use serde::{ser::SerializeStruct, Serialize, Serializer};
 
-const DEFAULT_LIMIT_SIZE: usize = 20;
 const DEFAULT_SLUG_LENGTH: usize = 8;
 
 pub type DateTime = chrono::DateTime<chrono::Utc>;
@@ -82,7 +81,7 @@ impl Serialize for Snippet {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum Direction {
     /// From older to newer snippets.
     #[allow(dead_code)]
@@ -91,7 +90,7 @@ pub enum Direction {
     Desc,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Pagination {
     /// Pagination direction.
     pub direction: Direction,
@@ -104,17 +103,21 @@ pub struct Pagination {
     pub marker: Option<String>,
 }
 
+impl Pagination {
+    pub const DEFAULT_LIMIT_SIZE: usize = 20;
+}
+
 impl Default for Pagination {
     fn default() -> Self {
         Pagination {
             direction: Direction::Desc,
-            limit: DEFAULT_LIMIT_SIZE,
+            limit: Self::DEFAULT_LIMIT_SIZE,
             marker: None,
         }
     }
 }
 
-#[derive(Debug, Default)]
+#[derive(Debug, Default, Clone)]
 pub struct ListSnippetsQuery {
     /// If set, only the snippets with the specified title will be returned.
     pub title: Option<String>,

src/storage/models.rs

@@ -3,5 +3,7 @@ mod content;
 mod tracing;
 
 pub use crate::web::auth::{AuthValidator, BearerAuth, JwtValidator, User};
-pub use crate::web::content::{Input, NegotiatedContentType, Output};
+pub use crate::web::content::{
+    Input, NegotiatedContentType, Output, PaginationLimit, WithHttpHeaders,
+};
 pub use crate::web::tracing::{RequestId, RequestIdHeader, RequestSpan};

src/web.rs

@@ -130,7 +130,7 @@ impl AuthValidator for JwtValidator {
 
                 let key = self
                     .jwks
-                    .find(&key_id)
+                    .find(key_id)
                     .filter(|key| key.alg == header.alg && key.r#use == "sig")
                     .ok_or_else(|| {
                         Error::Configuration(format!("Signing key {:?} can't be found", key_id))
@@ -141,7 +141,7 @@ impl AuthValidator for JwtValidator {
             alg => return Err(Error::Input(format!("Unsupported algorithm: {:?}", alg))),
         };
 
-        match jsonwebtoken::decode::<Claims>(&token, &key, &self.validation) {
+        match jsonwebtoken::decode::<Claims>(token, &key, &self.validation) {
             Ok(data) => Ok(User::Authenticated {
                 name: data.claims.sub,
                 permissions: data.claims.permissions,