feat: trending and categories routes

Author: Zomatree

crates/services/gifbox/src/api.rs

@@ -6,14 +6,14 @@ use revolt_config::config;
 use revolt_database::{Database, DatabaseInfo};
 use tokio::net::TcpListener;
 use utoipa::{
-    openapi::security::{Http, HttpAuthScheme, SecurityScheme},
+    openapi::security::{ApiKey, ApiKeyValue, SecurityScheme},
     Modify, OpenApi,
 };
 use utoipa_scalar::{Scalar, Servable as ScalarServable};
 
 use crate::tenor::Tenor;
 
-mod api;
+mod routes;
 mod tenor;
 mod types;
 
@@ -35,6 +35,26 @@ impl FromRef<AppState> for Tenor {
     }
 }
 
+struct TokenAddon;
+
+impl Modify for TokenAddon {
+    fn modify(&self, openapi: &mut utoipa::openapi::OpenApi) {
+        let components = openapi.components.get_or_insert_default();
+
+        components.add_security_scheme(
+            "User Token",
+            SecurityScheme::ApiKey(ApiKey::Header(ApiKeyValue::new(
+                "X-Session-Token".to_string(),
+            ))),
+        );
+
+        components.add_security_scheme(
+            "Bot Token",
+            SecurityScheme::ApiKey(ApiKey::Header(ApiKeyValue::new("X-Bot-Token".to_string()))),
+        );
+    }
+}
+
 #[tokio::main]
 async fn main() -> Result<(), std::io::Error> {
     // Configure logging and environment
@@ -43,36 +63,28 @@ async fn main() -> Result<(), std::io::Error> {
     // Configure API schema
     #[derive(OpenApi)]
     #[openapi(
-        modifiers(&SecurityAddon),
+        modifiers(&TokenAddon),
         paths(
-            api::root,
-            api::search,
+            routes::categories::categories,
+            routes::root::root,
+            routes::search::search,
+            routes::trending::trending,
+        ),
+        tags(
+            (name = "Misc", description = "Misc routes for microservice."),
+            (name = "GIFs", description = "All routes for requesting GIFs from tenor.")
         ),
         components(
             schemas(
                 revolt_result::Error,
                 revolt_result::ErrorType,
-                types::SearchResponse,
-                types::MediaObject,
                 types::MediaResult,
+                types::MediaObject,
             )
-        )
+        ),
     )]
     struct ApiDoc;
 
-    struct SecurityAddon;
-
-    impl Modify for SecurityAddon {
-        fn modify(&self, openapi: &mut utoipa::openapi::OpenApi) {
-            if let Some(components) = openapi.components.as_mut() {
-                components.add_security_scheme(
-                    "api_key",
-                    SecurityScheme::Http(Http::new(HttpAuthScheme::Bearer)),
-                )
-            }
-        }
-    }
-
     let config = config().await;
     let state = AppState {
         database: DatabaseInfo::Auto
@@ -85,7 +97,7 @@ async fn main() -> Result<(), std::io::Error> {
     // Configure Axum and router
     let app = Router::new()
         .merge(Scalar::with_url("/scalar", ApiDoc::openapi()))
-        .nest("/", api::router().await)
+        .nest("/", routes::router())
         .with_state(state);
 
     // Configure TCP listener and bind

crates/services/gifbox/src/main.rs

@@ -0,0 +1,47 @@
+use axum::{
+    extract::{Query, State},
+    Json,
+};
+use revolt_database::User;
+use revolt_result::{create_error, Result};
+use serde::Deserialize;
+use utoipa::IntoParams;
+
+use crate::{tenor, types};
+
+#[derive(Deserialize, IntoParams)]
+pub struct CategoriesQueryParams {
+    #[param(example = "en_US")]
+    pub locale: String,
+}
+
+/// Trending GIF categories
+#[utoipa::path(
+    get,
+    path = "/categories",
+    tag = "GIFs",
+    security(("User Token" = []), ("Bot Token" = [])),
+    params(CategoriesQueryParams),
+    responses(
+        (status = 200, description = "Categories results", body = inline(Vec<types::CategoryResponse>))
+    )
+)]
+pub async fn categories(
+    _user: User,
+    Query(params): Query<CategoriesQueryParams>,
+    State(tenor): State<tenor::Tenor>,
+) -> Result<Json<Vec<types::CategoryResponse>>> {
+    tenor
+        .categories(&params.locale)
+        .await
+        .map_err(|_| create_error!(InternalError))
+        .map(|results| {
+            (*results)
+                .clone()
+                .tags
+                .into_iter()
+                .map(|cat| cat.into())
+                .collect()
+        })
+        .map(Json)
+}

crates/services/gifbox/src/routes/categories.rs

@@ -0,0 +1,15 @@
+use crate::AppState;
+use axum::routing::{get, Router};
+
+pub mod categories;
+pub mod root;
+pub mod search;
+pub mod trending;
+
+pub fn router() -> Router<AppState> {
+    Router::new()
+        .route("/", get(root::root))
+        .route("/categories", get(categories::categories))
+        .route("/search", get(search::search))
+        .route("/trending", get(trending::trending))
+}

crates/services/gifbox/src/routes/mod.rs

@@ -0,0 +1,22 @@
+use axum::Json;
+
+use crate::types;
+
+/// Capture crate version from Cargo
+static CRATE_VERSION: &str = env!("CARGO_PKG_VERSION");
+
+/// Root response from service
+#[utoipa::path(
+    get,
+    path = "/",
+    tag = "Misc",
+    responses(
+        (status = 200, description = "Root response", body = inline(types::RootResponse))
+    )
+)]
+pub async fn root() -> Json<types::RootResponse<'static>> {
+    Json(types::RootResponse {
+        message: "Gifbox lives on!",
+        version: CRATE_VERSION,
+    })
+}

crates/services/gifbox/src/routes/root.rs

@@ -0,0 +1,51 @@
+use axum::{
+    extract::{Query, State},
+    Json,
+};
+use revolt_database::User;
+use revolt_result::{create_error, Result};
+use serde::Deserialize;
+use utoipa::IntoParams;
+
+use crate::{tenor, types};
+
+#[derive(Deserialize, IntoParams)]
+pub struct SearchQueryParams {
+    #[param(example = "Wave")]
+    pub query: String,
+    #[param(example = "en_US")]
+    pub locale: String,
+    pub limit: Option<u32>,
+    pub is_category: Option<bool>,
+    pub position: Option<String>,
+}
+
+/// Searches for GIFs with a query
+#[utoipa::path(
+    get,
+    path = "/search",
+    tag = "GIFs",
+    security(("User Token" = []), ("Bot Token" = [])),
+    params(SearchQueryParams),
+    responses(
+        (status = 200, description = "Search results", body = inline(types::PaginatedMediaResponse))
+    )
+)]
+pub async fn search(
+    _user: User,
+    Query(params): Query<SearchQueryParams>,
+    State(tenor): State<tenor::Tenor>,
+) -> Result<Json<types::PaginatedMediaResponse>> {
+    tenor
+        .search(
+            &params.query,
+            &params.locale,
+            params.limit.unwrap_or(50),
+            params.is_category.unwrap_or_default(),
+            params.position.as_deref().unwrap_or_default(),
+        )
+        .await
+        .map_err(|_| create_error!(InternalError))
+        .map(|results| results.as_ref().clone().into())
+        .map(Json)
+}

crates/services/gifbox/src/routes/search.rs

@@ -0,0 +1,45 @@
+use axum::{
+    extract::{Query, State},
+    Json,
+};
+use revolt_database::User;
+use revolt_result::{create_error, Result};
+use serde::{Deserialize};
+use utoipa::{IntoParams};
+
+use crate::{
+    tenor,
+    types,
+};
+
+#[derive(Deserialize, IntoParams)]
+pub struct TrendingQueryParams {
+    #[param(example = "en_US")]
+    pub locale: String,
+    pub limit: Option<u32>,
+    pub position: Option<String>
+}
+
+/// Trending GIFs
+#[utoipa::path(
+    get,
+    path = "/featured",
+    tag = "GIFs",
+    security(("User Token" = []), ("Bot Token" = [])),
+    params(TrendingQueryParams),
+    responses(
+        (status = 200, description = "Trending results", body = inline(types::PaginatedMediaResponse))
+    )
+)]
+pub async fn trending(
+    _user: User,
+    Query(params): Query<TrendingQueryParams>,
+    State(tenor): State<tenor::Tenor>,
+) -> Result<Json<types::PaginatedMediaResponse>> {
+    tenor
+        .featured(&params.locale, params.limit.unwrap_or(50), params.position.as_deref().unwrap_or_default())
+        .await
+        .map_err(|_| create_error!(InternalError))
+        .map(|results| results.as_ref().clone().into())
+        .map(Json)
+}