From e6b654a0b391e20d023d06533b53b2b7e7a17a52 Mon Sep 17 00:00:00 2001 From: nullishamy Date: Mon, 28 Apr 2025 23:21:59 +0100 Subject: [PATCH 1/2] feat: start on CRUD ops for new types --- .../src/types_rewrite/{fetch.rs => get.rs} | 16 +--- ferri-main/src/types_rewrite/make.rs | 30 ++++++ ferri-main/src/types_rewrite/mod.rs | 30 ++++-- ferri-server/src/endpoints/api/timeline.rs | 5 +- ferri-server/src/endpoints/custom.rs | 4 +- ferri-server/src/endpoints/inbox.rs | 96 +++++++++++++++++-- 6 files changed, 149 insertions(+), 32 deletions(-) rename ferri-main/src/types_rewrite/{fetch.rs => get.rs} (85%) create mode 100644 ferri-main/src/types_rewrite/make.rs diff --git a/ferri-main/src/types_rewrite/fetch.rs b/ferri-main/src/types_rewrite/get.rs similarity index 85% rename from ferri-main/src/types_rewrite/fetch.rs rename to ferri-main/src/types_rewrite/get.rs index 3e2cb69..b2ad17d 100644 --- a/ferri-main/src/types_rewrite/fetch.rs +++ b/ferri-main/src/types_rewrite/get.rs @@ -1,24 +1,18 @@ use crate::types_rewrite::{ObjectUuid, ObjectUri, db}; use sqlx::SqliteConnection; -use thiserror::Error; use tracing::info; use chrono::{NaiveDateTime, DateTime, Utc}; +use crate::types_rewrite::DbError; const SQLITE_TIME_FMT: &'static str = "%Y-%m-%d %H:%M:%S"; -#[derive(Debug, Error)] -pub enum FetchError { - #[error("an unknown error occured when fetching: {0}")] - Unknown(String) -} - fn parse_ts(ts: String) -> Option> { NaiveDateTime::parse_from_str(&ts, SQLITE_TIME_FMT) .ok() .map(|nt| nt.and_utc()) } -pub async fn user_by_id(id: ObjectUuid, conn: &mut SqliteConnection) -> Result { +pub async fn user_by_id(id: ObjectUuid, conn: &mut SqliteConnection) -> Result { info!("fetching user by uuid '{:?}' from the database", id); let record = sqlx::query!(r#" @@ -39,7 +33,7 @@ pub async fn user_by_id(id: ObjectUuid, conn: &mut SqliteConnection) -> Result Result Result Result { + let ts = user.created_at.to_rfc3339(); + sqlx::query!(r#" + INSERT INTO user (id, acct, url, created_at, remote, username, actor_id, display_name) + VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8) + "#, user.id.0, user.acct, user.url, ts, + user.remote, user.username, user.actor.id.0, user.display_name + ) + .execute(conn) + .await + .map_err(|e| DbError::CreationError(e.to_string()))?; + + Ok(user) +} + +pub async fn new_actor(actor: db::Actor, conn: &mut SqliteConnection) -> Result { + sqlx::query!(r#" + INSERT INTO actor (id, inbox, outbox) + VALUES (?1, ?2, ?3) + "#, actor.id.0, actor.inbox, actor.outbox) + .execute(conn) + .await + .map_err(|e| DbError::CreationError(e.to_string()))?; + + Ok(actor) +} diff --git a/ferri-main/src/types_rewrite/mod.rs b/ferri-main/src/types_rewrite/mod.rs index 1d03c12..317c667 100644 --- a/ferri-main/src/types_rewrite/mod.rs +++ b/ferri-main/src/types_rewrite/mod.rs @@ -1,7 +1,19 @@ use serde::{Serialize, Deserialize}; +use thiserror::Error; +use std::fmt::Debug; +use uuid::Uuid; pub mod convert; -pub mod fetch; +pub mod get; +pub mod make; + +#[derive(Debug, Error)] +pub enum DbError { + #[error("an unknown error occured when creating: {0}")] + CreationError(String), + #[error("an unknown error occured when fetching: {0}")] + FetchError(String) +} pub const AS_CONTEXT_RAW: &'static str = "https://www.w3.org/ns/activitystreams"; pub fn as_context() -> ObjectContext { @@ -15,12 +27,18 @@ pub enum ObjectContext { Vec(Vec), } -#[derive(Serialize, Deserialize, Debug, Eq, PartialEq)] +#[derive(Serialize, Deserialize, Debug, Eq, PartialEq, Clone)] pub struct ObjectUri(pub String); -#[derive(Serialize, Deserialize, Debug, Eq, PartialEq)] +#[derive(Serialize, Deserialize, Debug, Eq, PartialEq, Clone)] pub struct ObjectUuid(pub String); +impl ObjectUuid { + pub fn new() -> Self { + Self(Uuid::new_v4().to_string()) + } +} + #[derive(Serialize, Deserialize, Debug, Eq, PartialEq)] pub struct Object { #[serde(rename = "@context")] @@ -32,20 +50,20 @@ pub mod db { use chrono::{DateTime, Utc}; use super::*; - #[derive(Debug, Eq, PartialEq)] + #[derive(Debug, Eq, PartialEq, Clone)] pub struct Actor { pub id: ObjectUri, pub inbox: String, pub outbox: String, } - #[derive(Debug, Eq, PartialEq)] + #[derive(Debug, Eq, PartialEq, Clone)] pub struct UserPosts { // User may have no posts pub last_post_at: Option> } - #[derive(Debug, Eq, PartialEq)] + #[derive(Debug, Eq, PartialEq, Clone)] pub struct User { pub id: ObjectUuid, pub actor: Actor, diff --git a/ferri-server/src/endpoints/api/timeline.rs b/ferri-server/src/endpoints/api/timeline.rs index 7748621..c67f982 100644 --- a/ferri-server/src/endpoints/api/timeline.rs +++ b/ferri-server/src/endpoints/api/timeline.rs @@ -51,7 +51,8 @@ pub async fn home( display_name: String, username: String } - + + // FIXME: query! can't cope with this. returns a type error let posts = sqlx::query_as::<_, Post>( r#" WITH RECURSIVE get_home_timeline_with_boosts( @@ -84,8 +85,6 @@ pub async fn home( .await .unwrap(); - dbg!(&posts); - let mut out = Vec::::new(); for record in posts.iter() { let mut boost: Option> = None; diff --git a/ferri-server/src/endpoints/custom.rs b/ferri-server/src/endpoints/custom.rs index b4a0f7c..ff5150f 100644 --- a/ferri-server/src/endpoints/custom.rs +++ b/ferri-server/src/endpoints/custom.rs @@ -89,11 +89,11 @@ pub async fn test( outbound: &State, mut db: Connection ) -> &'static str { - use main::types_rewrite::{ObjectUuid, fetch, api}; + use main::types_rewrite::{ObjectUuid, get, api}; outbound.0.send(ap::QueueMessage::Heartbeat); let id = ObjectUuid("9b9d497b-2731-435f-a929-e609ca69dac9".to_string()); - let user= dbg!(fetch::user_by_id(id, &mut **db).await.unwrap()); + let user= dbg!(get::user_by_id(id, &mut **db).await.unwrap()); let apu: api::Account = user.into(); dbg!(apu); diff --git a/ferri-server/src/endpoints/inbox.rs b/ferri-server/src/endpoints/inbox.rs index 5d9971a..076db38 100644 --- a/ferri-server/src/endpoints/inbox.rs +++ b/ferri-server/src/endpoints/inbox.rs @@ -4,12 +4,15 @@ use main::ap; use rocket::serde::json::serde_json; use rocket::{State, post}; use rocket_db_pools::Connection; +use sqlx::SqliteConnection; use sqlx::Sqlite; use url::Url; use uuid::Uuid; use tracing::{event, span, Level, debug, warn, info, error}; use crate::http_wrapper::HttpWrapper; +use main::types_rewrite::{make, db, ObjectUuid, ObjectUri, self}; + use crate::{ Db, http::HttpClient, @@ -103,22 +106,92 @@ async fn create_follow( .unwrap(); } +struct RemoteInfo { + acct: String, + web_url: String, + is_remote: bool, +} + +fn get_remote_info(actor_url: &str, person: &Person) -> RemoteInfo { + let url = Url::parse(&actor_url).unwrap(); + let host = url.host_str().unwrap(); + + let (acct, remote) = if host != "ferri.amy.mov" { + (format!("{}@{}", person.preferred_username, host), true) + } else { + (person.preferred_username.clone(), false) + }; + + let url = format!("https://ferri.amy.mov/{}", acct); + + RemoteInfo { + acct: acct.to_string(), + web_url: url, + is_remote: remote + } +} + +async fn resolve_actor<'a>( + actor_url: &str, + http: &HttpWrapper<'a>, + conn: &mut SqliteConnection +) -> Result { + let person = { + let res = http.get_person(&actor_url).await; + if let Err(e) = res { + error!("could not load user {}: {}", actor_url, e.to_string()); + return Err(types_rewrite::DbError::FetchError( + format!("could not load user {}: {}", actor_url, e.to_string()) + )) + } + + res.unwrap() + }; + + let user_id = ObjectUuid::new(); + let remote_info = get_remote_info(actor_url, &person); + + let actor = db::Actor { + id: ObjectUri(actor_url.to_string()), + inbox: person.inbox.clone(), + outbox: person.outbox.clone(), + }; + + info!("creating actor {}", actor_url); + + let actor = make::new_actor(actor.clone(), conn).await.unwrap_or(actor); + + info!("creating user {} ({:#?})", remote_info.acct, person); + + let user = db::User { + id: user_id, + actor, + username: person.name, + display_name: person.preferred_username, + acct: remote_info.acct, + remote: remote_info.is_remote, + url: remote_info.web_url, + created_at: main::ap::now(), + + posts: db::UserPosts { + last_post_at: None + } + }; + + Ok(make::new_user(user.clone(), conn).await.unwrap_or(user)) +} + async fn handle_follow_activity<'a>( followed_account: &str, activity: activity::FollowActivity, http: HttpWrapper<'a>, mut db: Connection, ) { - let user = http.get_person(&activity.actor).await; - if let Err(e) = user { - error!("could not load user {}: {}", activity.actor, e.to_string()); - return - } - - let user = user.unwrap(); + let actor = resolve_actor(&activity.actor, &http, &mut **db) + .await.unwrap(); - create_actor(&user, &activity.actor, &mut **db).await; - create_user(&user, &activity.actor, &mut **db).await; + info!("{:?} follows {}", actor, followed_account); + create_follow(&activity, &mut **db).await; let follower = ap::User::from_actor_id(&activity.actor, &mut **db).await; @@ -226,15 +299,18 @@ async fn handle_boost_activity<'a>( let reblog_id = ap::new_id(); let attr_id = attributed_user.id(); + // HACK: ON CONFLICT is to avoid duplicate remote posts coming in + // check this better in future sqlx::query!(" INSERT INTO post (id, uri, user_id, content, created_at) VALUES (?1, ?2, ?3, ?4, ?5) + ON CONFLICT(uri) DO NOTHING ", reblog_id, post.id, attr_id, post.content, post.ts) .execute(&mut **db) .await .unwrap(); - let uri = format!("https://ferri.amy.mov/users/{}/posts/{}", actor_user.id(), post.id); + let uri = format!("https://ferri.amy.mov/users/{}/posts/{}", actor_user.id(), base_id); let user_id = actor_user.id(); sqlx::query!(" From 5f346922f5682a89243dfcc2b2a8399f23be7a65 Mon Sep 17 00:00:00 2001 From: nullishamy Date: Mon, 28 Apr 2025 23:31:09 +0100 Subject: [PATCH 2/2] chore: move a bunch of instance types; deprecate old types --- ferri-main/src/types_rewrite/mod.rs | 101 ++++++++++++++++++ ferri-server/src/endpoints/api/instance.rs | 2 +- ferri-server/src/endpoints/inbox.rs | 35 +++---- ferri-server/src/http_wrapper.rs | 4 +- ferri-server/src/types/content.rs | 1 + ferri-server/src/types/instance.rs | 115 --------------------- ferri-server/src/types/mod.rs | 3 +- ferri-server/src/types/oauth.rs | 2 + ferri-server/src/types/webfinger.rs | 2 + 9 files changed, 128 insertions(+), 137 deletions(-) delete mode 100644 ferri-server/src/types/instance.rs diff --git a/ferri-main/src/types_rewrite/mod.rs b/ferri-main/src/types_rewrite/mod.rs index 317c667..ac55ae3 100644 --- a/ferri-main/src/types_rewrite/mod.rs +++ b/ferri-main/src/types_rewrite/mod.rs @@ -171,6 +171,107 @@ pub mod api { pub value: String, pub verified_at: Option, } + + #[derive(Debug, Serialize, Deserialize)] + pub struct Instance { + pub domain: String, + pub title: String, + pub version: String, + pub source_url: String, + pub description: String, + pub thumbnail: Thumbnail, + pub icon: Vec, + pub languages: Vec, + pub configuration: Configuration, + pub registrations: Registrations, + pub contact: Contact, + } + + #[derive(Debug, Serialize, Deserialize)] + pub struct Configuration { + pub urls: Urls, + pub accounts: Accounts, + pub statuses: Statuses, + pub media_attachments: MediaAttachments, + pub polls: Polls, + pub translation: Translation, + } + + #[derive(Debug, Serialize, Deserialize)] + pub struct Accounts { + pub max_featured_tags: i64, + pub max_pinned_statuses: i64, + } + + #[derive(Debug, Serialize, Deserialize)] + pub struct MediaAttachments { + pub supported_mime_types: Vec, + pub description_limit: i64, + pub image_size_limit: i64, + pub image_matrix_limit: i64, + pub video_size_limit: i64, + pub video_frame_rate_limit: i64, + pub video_matrix_limit: i64, + } + + #[derive(Debug, Serialize, Deserialize)] + pub struct Polls { + pub max_options: i64, + pub max_characters_per_option: i64, + pub min_expiration: i64, + pub max_expiration: i64, + } + + #[derive(Debug, Serialize, Deserialize)] + pub struct Statuses { + pub max_characters: i64, + pub max_media_attachments: i64, + pub characters_reserved_per_url: i64, + } + + #[derive(Debug, Serialize, Deserialize)] + pub struct Translation { + pub enabled: bool, + } + + #[derive(Debug, Serialize, Deserialize)] + pub struct Urls { + pub streaming: String, + pub about: String, + pub privacy_policy: String, + pub terms_of_service: String, + } + + #[derive(Debug, Serialize, Deserialize)] + pub struct Contact { + pub email: String, + } + + #[derive(Debug, Serialize, Deserialize)] + pub struct Field { + pub name: String, + pub value: String, + } + + #[derive(Debug, Serialize, Deserialize)] + pub struct Icon { + pub src: String, + pub size: String, + } + + #[derive(Debug, Serialize, Deserialize)] + pub struct Registrations { + pub enabled: bool, + pub approval_required: bool, + pub reason_required: bool, + pub message: Option, + pub min_age: i64, + } + + #[derive(Debug, Serialize, Deserialize)] + pub struct Thumbnail { + pub url: String, + } } #[cfg(test)] diff --git a/ferri-server/src/endpoints/api/instance.rs b/ferri-server/src/endpoints/api/instance.rs index 9fab90f..81c0d37 100644 --- a/ferri-server/src/endpoints/api/instance.rs +++ b/ferri-server/src/endpoints/api/instance.rs @@ -2,7 +2,7 @@ use rocket::{get, serde::json::Json, State}; use crate::Config; -use crate::types::instance::{ +use main::types_rewrite::api::{ Accounts, Configuration, Contact, Instance, MediaAttachments, Polls, Registrations, Statuses, Thumbnail, Translation, Urls, }; diff --git a/ferri-server/src/endpoints/inbox.rs b/ferri-server/src/endpoints/inbox.rs index 076db38..c8b05f1 100644 --- a/ferri-server/src/endpoints/inbox.rs +++ b/ferri-server/src/endpoints/inbox.rs @@ -1,6 +1,5 @@ use chrono::Local; use tracing::Instrument; -use main::ap; use rocket::serde::json::serde_json; use rocket::{State, post}; use rocket_db_pools::Connection; @@ -11,12 +10,12 @@ use uuid::Uuid; use tracing::{event, span, Level, debug, warn, info, error}; use crate::http_wrapper::HttpWrapper; -use main::types_rewrite::{make, db, ObjectUuid, ObjectUri, self}; +use main::types_rewrite::{make, db, ObjectUuid, ObjectUri, self, ap}; use crate::{ Db, http::HttpClient, - types::{Person, content::Post, activity}, + types::{content::Post, activity}, }; fn handle_delete_activity(activity: activity::DeleteActivity) { @@ -24,7 +23,7 @@ fn handle_delete_activity(activity: activity::DeleteActivity) { } async fn create_actor( - user: &Person, + user: &ap::Person, actor: &str, conn: impl sqlx::Executor<'_, Database = Sqlite>, ) { @@ -44,7 +43,7 @@ async fn create_actor( } async fn create_user( - user: &Person, + user: &ap::Person, actor: &str, conn: impl sqlx::Executor<'_, Database = Sqlite>, ) { @@ -112,7 +111,7 @@ struct RemoteInfo { is_remote: bool, } -fn get_remote_info(actor_url: &str, person: &Person) -> RemoteInfo { +fn get_remote_info(actor_url: &str, person: &ap::Person) -> RemoteInfo { let url = Url::parse(&actor_url).unwrap(); let host = url.host_str().unwrap(); @@ -194,18 +193,18 @@ async fn handle_follow_activity<'a>( create_follow(&activity, &mut **db).await; - let follower = ap::User::from_actor_id(&activity.actor, &mut **db).await; - let followed = ap::User::from_id(&followed_account, &mut **db).await.unwrap(); - let outbox = ap::Outbox::for_user(followed.clone(), http.client()); + let follower = main::ap::User::from_actor_id(&activity.actor, &mut **db).await; + let followed = main::ap::User::from_id(&followed_account, &mut **db).await.unwrap(); + let outbox = main::ap::Outbox::for_user(followed.clone(), http.client()); - let activity = ap::Activity { + let activity = main::ap::Activity { id: format!("https://ferri.amy.mov/activities/{}", Uuid::new_v4()), - ty: ap::ActivityType::Accept, + ty: main::ap::ActivityType::Accept, object: activity.id, ..Default::default() }; - let req = ap::OutgoingActivity { + let req = main::ap::OutgoingActivity { signed_by: format!( "https://ferri.amy.mov/users/{}#main-key", followed.username() @@ -290,13 +289,13 @@ async fn handle_boost_activity<'a>( debug!("creating user {}", attribution); create_user(&post_user, &attribution, &mut **db).await; - let attributed_user = ap::User::from_actor_id(&attribution, &mut **db).await; - let actor_user = ap::User::from_actor_id(&activity.actor, &mut **db).await; + let attributed_user = main::ap::User::from_actor_id(&attribution, &mut **db).await; + let actor_user = main::ap::User::from_actor_id(&activity.actor, &mut **db).await; - let base_id = ap::new_id(); - let now = ap::new_ts(); + let base_id = main::ap::new_id(); + let now = main::ap::new_ts(); - let reblog_id = ap::new_id(); + let reblog_id = main::ap::new_id(); let attr_id = attributed_user.id(); // HACK: ON CONFLICT is to avoid duplicate remote posts coming in @@ -345,7 +344,7 @@ async fn handle_create_activity<'a>( debug!("creating user {}", activity.actor); create_user(&user, &activity.actor, &mut **db).await; - let user = ap::User::from_actor_id(&activity.actor, &mut **db).await; + let user = main::ap::User::from_actor_id(&activity.actor, &mut **db).await; debug!("user created {:?}", user); let user_id = user.id(); diff --git a/ferri-server/src/http_wrapper.rs b/ferri-server/src/http_wrapper.rs index 0470b3f..6592438 100644 --- a/ferri-server/src/http_wrapper.rs +++ b/ferri-server/src/http_wrapper.rs @@ -1,7 +1,7 @@ use thiserror::Error; use tracing::{error, event, Level}; use crate::http::HttpClient; -use crate::types::Person; +use main::types_rewrite::ap; use std::fmt::Debug; pub struct HttpWrapper<'a> { @@ -65,7 +65,7 @@ impl <'a> HttpWrapper<'a> { Ok(decoded.unwrap()) } - pub async fn get_person(&self, url: &str) -> Result { + pub async fn get_person(&self, url: &str) -> Result { self.get("Person", url).await } } diff --git a/ferri-server/src/types/content.rs b/ferri-server/src/types/content.rs index e35c5d9..0ba38d4 100644 --- a/ferri-server/src/types/content.rs +++ b/ferri-server/src/types/content.rs @@ -2,6 +2,7 @@ use rocket::serde::{Deserialize, Serialize}; #[derive(Serialize, Deserialize, Debug, Default)] #[serde(crate = "rocket::serde")] +#[deprecated] pub struct Post { // FIXME: This is because Masto sends an array but we don't care #[serde(rename = "@context")] diff --git a/ferri-server/src/types/instance.rs b/ferri-server/src/types/instance.rs deleted file mode 100644 index bfc7c1d..0000000 --- a/ferri-server/src/types/instance.rs +++ /dev/null @@ -1,115 +0,0 @@ -use rocket::serde::{Deserialize, Serialize}; - -#[derive(Debug, Serialize, Deserialize)] -#[serde(crate = "rocket::serde")] -pub struct Instance { - pub domain: String, - pub title: String, - pub version: String, - pub source_url: String, - pub description: String, - pub thumbnail: Thumbnail, - pub icon: Vec, - pub languages: Vec, - pub configuration: Configuration, - pub registrations: Registrations, - pub contact: Contact, -} - -#[derive(Debug, Serialize, Deserialize)] -#[serde(crate = "rocket::serde")] -pub struct Configuration { - pub urls: Urls, - pub accounts: Accounts, - pub statuses: Statuses, - pub media_attachments: MediaAttachments, - pub polls: Polls, - pub translation: Translation, -} - -#[derive(Debug, Serialize, Deserialize)] -#[serde(crate = "rocket::serde")] -pub struct Accounts { - pub max_featured_tags: i64, - pub max_pinned_statuses: i64, -} - -#[derive(Debug, Serialize, Deserialize)] -#[serde(crate = "rocket::serde")] -pub struct MediaAttachments { - pub supported_mime_types: Vec, - pub description_limit: i64, - pub image_size_limit: i64, - pub image_matrix_limit: i64, - pub video_size_limit: i64, - pub video_frame_rate_limit: i64, - pub video_matrix_limit: i64, -} - -#[derive(Debug, Serialize, Deserialize)] -#[serde(crate = "rocket::serde")] -pub struct Polls { - pub max_options: i64, - pub max_characters_per_option: i64, - pub min_expiration: i64, - pub max_expiration: i64, -} - -#[derive(Debug, Serialize, Deserialize)] -#[serde(crate = "rocket::serde")] -pub struct Statuses { - pub max_characters: i64, - pub max_media_attachments: i64, - pub characters_reserved_per_url: i64, -} - -#[derive(Debug, Serialize, Deserialize)] -#[serde(crate = "rocket::serde")] -pub struct Translation { - pub enabled: bool, -} - -#[derive(Debug, Serialize, Deserialize)] -#[serde(crate = "rocket::serde")] -pub struct Urls { - pub streaming: String, - pub about: String, - pub privacy_policy: String, - pub terms_of_service: String, -} - -#[derive(Debug, Serialize, Deserialize)] -#[serde(crate = "rocket::serde")] -pub struct Contact { - pub email: String, -} - -#[derive(Debug, Serialize, Deserialize)] -#[serde(crate = "rocket::serde")] -pub struct Field { - pub name: String, - pub value: String, -} - -#[derive(Debug, Serialize, Deserialize)] -#[serde(crate = "rocket::serde")] -pub struct Icon { - pub src: String, - pub size: String, -} - -#[derive(Debug, Serialize, Deserialize)] -#[serde(crate = "rocket::serde")] -pub struct Registrations { - pub enabled: bool, - pub approval_required: bool, - pub reason_required: bool, - pub message: Option, - pub min_age: i64, -} - -#[derive(Debug, Serialize, Deserialize)] -#[serde(crate = "rocket::serde")] -pub struct Thumbnail { - pub url: String, -} diff --git a/ferri-server/src/types/mod.rs b/ferri-server/src/types/mod.rs index 7767a8d..eb0c3c5 100644 --- a/ferri-server/src/types/mod.rs +++ b/ferri-server/src/types/mod.rs @@ -1,6 +1,5 @@ pub mod activity; pub mod content; -pub mod instance; pub mod oauth; pub mod webfinger; @@ -9,6 +8,7 @@ use rocket::serde::{Deserialize, Serialize}; #[derive(Serialize, Deserialize, Debug)] #[serde(rename_all = "camelCase")] #[serde(crate = "rocket::serde")] +#[deprecated] pub struct UserKey { pub id: String, pub owner: String, @@ -19,6 +19,7 @@ pub struct UserKey { #[derive(Serialize, Deserialize, Debug)] #[serde(rename_all = "camelCase")] #[serde(crate = "rocket::serde")] +#[deprecated] pub struct Person { // FIXME: This is because Masto sends an array but we don't care #[serde(rename = "@context")] diff --git a/ferri-server/src/types/oauth.rs b/ferri-server/src/types/oauth.rs index 8791fe3..7bc1b27 100644 --- a/ferri-server/src/types/oauth.rs +++ b/ferri-server/src/types/oauth.rs @@ -5,6 +5,7 @@ use rocket::{ #[derive(Serialize, Deserialize, Debug, FromForm, Clone)] #[serde(crate = "rocket::serde")] +#[deprecated] pub struct App { pub client_name: String, pub redirect_uris: Vec, @@ -13,6 +14,7 @@ pub struct App { #[derive(Serialize, Deserialize, Debug)] #[serde(crate = "rocket::serde")] +#[deprecated] pub struct CredentialApplication { pub name: String, pub scopes: String, diff --git a/ferri-server/src/types/webfinger.rs b/ferri-server/src/types/webfinger.rs index a97c7dd..71f7d2b 100644 --- a/ferri-server/src/types/webfinger.rs +++ b/ferri-server/src/types/webfinger.rs @@ -2,6 +2,7 @@ use rocket::serde::{Deserialize, Serialize}; #[derive(Deserialize, Serialize, Debug)] #[serde(crate = "rocket::serde")] +#[deprecated] pub struct Link { pub rel: String, #[serde(rename = "type")] @@ -11,6 +12,7 @@ pub struct Link { #[derive(Deserialize, Serialize, Debug)] #[serde(crate = "rocket::serde")] +#[deprecated] pub struct WebfingerResponse { pub subject: String, pub aliases: Vec,