feat(delta): example implementation of new core models

crates/delta/Cargo.toml

@@ -57,6 +57,7 @@ revolt-quark = { path = "../quark" }
 
 # core
 revolt-database = { path = "../core/database" }
+revolt-models = { path = "../core/models", features = [ "schemas" ] }
 
 [build-dependencies]
 vergen = "7.5.0"

crates/delta/src/routes/bots/fetch.rs

@@ -1,11 +1,11 @@
-use revolt_quark::{
-    models::{Bot, User},
-    Db, Error, Ref, Result,
-};
-use rocket::serde::json::Json;
+use revolt_database::Database;
+use revolt_models::Bot;
+use revolt_quark::{models::User, Db, Error, Ref, Result};
+use rocket::{serde::json::Json, State};
 use serde::Serialize;
 
 /// # Bot Response
+/// TODO: move to revolt-models
 #[derive(Serialize, JsonSchema)]
 pub struct BotResponse {
     /// Bot object
@@ -19,18 +19,23 @@ pub struct BotResponse {
 /// Fetch details of a bot you own by its id.
 #[openapi(tag = "Bots")]
 #[get("/<target>")]
-pub async fn fetch_bot(db: &Db, user: User, target: Ref) -> Result<Json<BotResponse>> {
+pub async fn fetch_bot(
+    legacy_db: &Db,
+    db: &State<Database>,
+    user: User,
+    target: Ref,
+) -> Result<Json<BotResponse>> {
     if user.bot.is_some() {
         return Err(Error::IsBot);
     }
 
-    let bot = target.as_bot(db).await?;
+    let bot = db.fetch_bot(&target.id).await.map_err(Error::from_core)?;
     if bot.owner != user.id {
         return Err(Error::NotFound);
     }
 
     Ok(Json(BotResponse {
-        user: db.fetch_user(&bot.id).await?.foreign(),
-        bot,
+        user: legacy_db.fetch_user(&bot.id).await?.foreign(),
+        bot: bot.into(),
     }))
 }

crates/delta/src/routes/bots/fetch_public.rs

@@ -1,44 +1,32 @@
-use revolt_quark::{
-    models::{File, User},
-    Db, Error, Ref, Result,
-};
+use revolt_database::Database;
+use revolt_models::PublicBot;
+use revolt_quark::{models::User, Db, Error, Ref, Result};
 
 use rocket::serde::json::Json;
-use serde::{Deserialize, Serialize};
-
-/// # Public Bot
-#[derive(Serialize, Deserialize, JsonSchema)]
-pub struct PublicBot {
-    /// Bot Id
-    #[serde(rename = "_id")]
-    id: String,
-    /// Bot Username
-    username: String,
-    /// Profile Avatar
-    #[serde(skip_serializing_if = "Option::is_none")]
-    avatar: Option<File>,
-    /// Profile Description
-    #[serde(skip_serializing_if = "Option::is_none")]
-    description: Option<String>,
-}
+use rocket::State;
 
 /// # Fetch Public Bot
 ///
 /// Fetch details of a public (or owned) bot by its id.
 #[openapi(tag = "Bots")]
 #[get("/<target>/invite")]
-pub async fn fetch_public_bot(db: &Db, user: Option<User>, target: Ref) -> Result<Json<PublicBot>> {
-    let bot = target.as_bot(db).await?;
+pub async fn fetch_public_bot(
+    legacy_db: &Db,
+    db: &State<Database>,
+    user: Option<User>,
+    target: Ref,
+) -> Result<Json<PublicBot>> {
+    let bot = db.fetch_bot(&target.id).await.map_err(Error::from_core)?;
     if !bot.public && user.map_or(true, |x| x.id != bot.owner) {
         return Err(Error::NotFound);
     }
 
-    let user = db.fetch_user(&bot.id).await?;
+    let user = legacy_db.fetch_user(&bot.id).await?;
 
-    Ok(Json(PublicBot {
-        id: bot.id,
-        username: user.username,
-        avatar: user.avatar,
-        description: user.profile.and_then(|p| p.content),
-    }))
+    Ok(Json(PublicBot::from(
+        bot,
+        user.username,
+        user.avatar.map(|f| f.id),
+        user.profile.and_then(|p| p.content),
+    )))
 }