HoovesSocial/hippofish
2
0
Fork 0
Code Issues 3 Pull requests 1 Projects Releases Packages Wiki Activity Actions

wip: upgrade seaorm

Browse source
This commit is contained in:
Namekuji 2023-09-06 23:16:00 -04:00
parent 39c20d947c
commit 49ce084be4
No known key found for this signature in database
GPG key ID: 1D62332C07FBA532
35 changed files with 902 additions and 1272 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1520
packages/backend/native-utils/Cargo.lock generated
View file

File diff suppressed because it is too large Load diff

3
packages/backend/native-utils/Cargo.toml
View file

@ -8,7 +8,6 @@ members = ["migration", "scylla-migration"]
[features]
default = []
noarray = []
napi = ["dep:napi", "dep:napi-derive"]
[lib]
@ -25,7 +24,7 @@ once_cell = "1.17.1"
parse-display = "0.8.0"
rand = "0.8.5"
schemars = { version = "0.8.12", features = ["chrono"] }
sea-orm = { version = "0.11.3", features = ["sqlx-postgres", "postgres-array", "sqlx-sqlite", "runtime-tokio-rustls"] }
sea-orm = { version = "0.12.2", features = ["sqlx-postgres", "runtime-tokio-rustls"] }
serde = { version = "1.0.163", features = ["derive"] }
serde_json = "1.0.96"
thiserror = "1.0.40"

5
packages/backend/native-utils/migration/Cargo.toml
View file

@ -22,17 +22,16 @@ serde_yaml = "0.9.21"
serde = { version = "1.0.163", features = ["derive"] }
urlencoding = "2.1.2"
redis = { version = "0.23.0", features = ["tokio-rustls-comp"] }
sea-orm = "0.11.3"
sea-orm = "0.12.2"
url = { version = "2.4.0", features = ["serde"] }
basen = "0.1.0"
[dependencies.sea-orm-migration]
version = "0.11.0"
version = "0.12.0"
features = [
# Enable at least one `ASYNC_RUNTIME` and `DATABASE_DRIVER` feature if you want to run migration via CLI.
# View the list of supported features at https://www.sea-ql.org/SeaORM/docs/install-and-config/database-and-async-runtime.
# e.g.
"runtime-tokio-rustls", # `ASYNC_RUNTIME` feature
"sqlx-postgres", # `DATABASE_DRIVER` feature
"sqlx-sqlite",
]

2
packages/backend/native-utils/package.json
View file

@ -48,6 +48,6 @@
"lint": "cargo clippy --fix --allow-dirty --allow-staged && cargo fmt --all -- --check",
"cargo:test": "pnpm run cargo:unit && pnpm run cargo:integration",
"cargo:unit": "cargo test unit_test && cargo test -F napi unit_test",
"cargo:integration": "cargo test -F noarray int_test -- --test-threads=1"
"cargo:integration": "cargo test int_test"
}
}

2
packages/backend/native-utils/scylla-migration/Cargo.toml
View file

@ -9,9 +9,9 @@ edition = "2021"
chrono = "0.4.26"
clap = { version = "4.3.11", features = ["derive"] }
scylla = "0.8.2"
sea-orm = { version = "0.12.2", features = ["sqlx-postgres", "runtime-tokio-rustls"] }
serde = { version = "1.0.171", features = ["derive"] }
serde_yaml = "0.9.22"
sqlx = { version = "0.6.0", features = ["runtime-tokio-rustls", "postgres"] }
thiserror = "1.0.43"
tokio = { version = "1.29.1", features = ["full"] }
urlencoding = "2.1.3"

3
packages/backend/native-utils/scylla-migration/src/error.rs
View file

@ -5,6 +5,7 @@ use scylla::{
query_result::SingleRowTypedError,
},
};
use sea_orm::DbErr;
use std::io;
use thiserror::Error;
@ -21,5 +22,5 @@ pub enum Error {
#[error("File error: {0}")]
File(#[from] io::Error),
#[error("PostgreSQL error: {0}")]
Postgres(#[from] sqlx::Error),
Postgres(#[from] DbErr),
}

26
packages/backend/native-utils/scylla-migration/src/setup.rs
View file

@ -1,5 +1,5 @@
use scylla::{Session, SessionBuilder};
use sqlx::{Connection, PgConnection};
use sea_orm::{ConnectionTrait, Database, Statement};
use urlencoding::encode;
use crate::{
@ -38,7 +38,8 @@ impl Initializer {
}
pub(crate) async fn setup(&self) -> Result<(), Error> {
let mut conn = PgConnection::connect(&self.postgres_url).await?;
let pool = Database::connect(&self.postgres_url).await?;
let db_backend = pool.get_database_backend();
let fk_pairs = vec![
("channel_note_pining", "FK_10b19ef67d297ea9de325cd4502"),
@ -52,15 +53,26 @@ impl Initializer {
("user_note_pining", "FK_68881008f7c3588ad7ecae471cf"),
];
for (table, fk) in fk_pairs {
sqlx::query(&format!("ALTER TABLE {} DROP CONSTRAINT \"{}\"", table, fk))
.execute(&mut conn)
pool.execute(Statement::from_string(
db_backend.to_owned(),
format!("ALTER TABLE {} DROP CONSTRAINT \"{}\"", table, fk),
))
.await?;
}
let tables = vec!["note_reaction", "note_edit", "poll", "poll_vote", "notification", "note"];
let tables = vec![
"note_reaction",
"note_edit",
"poll",
"poll_vote",
"notification",
"note",
];
for table in tables {
sqlx::query(&format!("DROP TABLE {}", table))
.execute(&mut conn)
pool.execute(Statement::from_string(
db_backend,
format!("DROP TABLE {}", table),
))
.await?;
}

1
packages/backend/native-utils/src/model/entity.rs
View file

@ -32,7 +32,6 @@ pub mod migrations;
pub mod moderation_log;
pub mod muted_note;
pub mod muting;
pub mod newtype;
pub mod note;
pub mod note_edit;
pub mod note_favorite;

4
packages/backend/native-utils/src/model/entity/access_token.rs
View file

@ -2,8 +2,6 @@
use sea_orm::entity::prelude::*;
use super::newtype::StringVec;
#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Default)]
#[sea_orm(table_name = "access_token")]
pub struct Model {
@ -24,7 +22,7 @@ pub struct Model {
pub description: Option<String>,
#[sea_orm(column_name = "iconUrl")]
pub icon_url: Option<String>,
pub permission: StringVec,
pub permission: Vec<String>,
pub fetched: bool,
}

10
packages/backend/native-utils/src/model/entity/antenna.rs
View file

@ -1,6 +1,6 @@
//! `SeaORM` Entity. Generated by sea-orm-codegen 0.11.3
use super::{newtype, sea_orm_active_enums::AntennaSrcEnum};
use super::sea_orm_active_enums::AntennaSrcEnum;
use sea_orm::entity::prelude::*;
#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Default)]
@ -17,7 +17,7 @@ pub struct Model {
#[sea_orm(column_name = "userListId")]
pub user_list_id: Option<String>,
#[sea_orm(column_type = "JsonBinary")]
pub keywords: newtype::JsonKeyword,
pub keywords: Json,
#[sea_orm(column_name = "withFile")]
pub with_file: bool,
pub expression: Option<String>,
@ -28,11 +28,11 @@ pub struct Model {
pub with_replies: bool,
#[sea_orm(column_name = "userGroupJoiningId")]
pub user_group_joining_id: Option<String>,
pub users: newtype::StringVec,
pub users: Vec<String>,
#[sea_orm(column_name = "excludeKeywords", column_type = "JsonBinary")]
pub exclude_keywords: newtype::JsonKeyword,
pub exclude_keywords: Json,
#[sea_orm(column_type = "JsonBinary")]
pub instances: newtype::JsonStringVec,
pub instances: Json,
}
#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]

4
packages/backend/native-utils/src/model/entity/app.rs
View file

@ -2,8 +2,6 @@
use sea_orm::entity::prelude::*;
use super::newtype::StringVec;
#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Default)]
#[sea_orm(table_name = "app")]
pub struct Model {
@ -16,7 +14,7 @@ pub struct Model {
pub secret: String,
pub name: String,
pub description: String,
pub permission: StringVec,
pub permission: Vec<String>,
#[sea_orm(column_name = "callbackUrl")]
pub callback_url: Option<String>,
}

4
packages/backend/native-utils/src/model/entity/emoji.rs
View file

@ -2,8 +2,6 @@
use sea_orm::entity::prelude::*;
use super::newtype::StringVec;
#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Default)]
#[sea_orm(table_name = "emoji")]
pub struct Model {
@ -17,7 +15,7 @@ pub struct Model {
pub original_url: String,
pub uri: Option<String>,
pub r#type: Option<String>,
pub aliases: StringVec,
pub aliases: Vec<String>,
pub category: Option<String>,
#[sea_orm(column_name = "publicUrl")]
pub public_url: String,

6
packages/backend/native-utils/src/model/entity/gallery_post.rs
View file

@ -2,8 +2,6 @@
use sea_orm::entity::prelude::*;
use super::newtype::StringVec;
#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Default)]
#[sea_orm(table_name = "gallery_post")]
pub struct Model {
@ -18,12 +16,12 @@ pub struct Model {
#[sea_orm(column_name = "userId")]
pub user_id: String,
#[sea_orm(column_name = "fileIds")]
pub file_ids: StringVec,
pub file_ids: Vec<String>,
#[sea_orm(column_name = "isSensitive")]
pub is_sensitive: bool,
#[sea_orm(column_name = "likedCount")]
pub liked_count: i32,
pub tags: StringVec,
pub tags: Vec<String>,
}
#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]

14
packages/backend/native-utils/src/model/entity/hashtag.rs
View file

@ -2,8 +2,6 @@
use sea_orm::entity::prelude::*;
use super::newtype::StringVec;
#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Default)]
#[sea_orm(table_name = "hashtag")]
pub struct Model {
@ -11,27 +9,27 @@ pub struct Model {
pub id: String,
pub name: String,
#[sea_orm(column_name = "mentionedUserIds")]
pub mentioned_user_ids: StringVec,
pub mentioned_user_ids: Vec<String>,
#[sea_orm(column_name = "mentionedUsersCount")]
pub mentioned_users_count: i32,
#[sea_orm(column_name = "mentionedLocalUserIds")]
pub mentioned_local_user_ids: StringVec,
pub mentioned_local_user_ids: Vec<String>,
#[sea_orm(column_name = "mentionedLocalUsersCount")]
pub mentioned_local_users_count: i32,
#[sea_orm(column_name = "mentionedRemoteUserIds")]
pub mentioned_remote_user_ids: StringVec,
pub mentioned_remote_user_ids: Vec<String>,
#[sea_orm(column_name = "mentionedRemoteUsersCount")]
pub mentioned_remote_users_count: i32,
#[sea_orm(column_name = "attachedUserIds")]
pub attached_user_ids: StringVec,
pub attached_user_ids: Vec<String>,
#[sea_orm(column_name = "attachedUsersCount")]
pub attached_users_count: i32,
#[sea_orm(column_name = "attachedLocalUserIds")]
pub attached_local_user_ids: StringVec,
pub attached_local_user_ids: Vec<String>,
#[sea_orm(column_name = "attachedLocalUsersCount")]
pub attached_local_users_count: i32,
#[sea_orm(column_name = "attachedRemoteUserIds")]
pub attached_remote_user_ids: StringVec,
pub attached_remote_user_ids: Vec<String>,
#[sea_orm(column_name = "attachedRemoteUsersCount")]
pub attached_remote_users_count: i32,
}

4
packages/backend/native-utils/src/model/entity/messaging_message.rs
View file

@ -2,8 +2,6 @@
use sea_orm::entity::prelude::*;
use super::newtype::StringVec;
#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Default)]
#[sea_orm(table_name = "messaging_message")]
pub struct Model {
@ -22,7 +20,7 @@ pub struct Model {
pub file_id: Option<String>,
#[sea_orm(column_name = "groupId")]
pub group_id: Option<String>,
pub reads: StringVec,
pub reads: Vec<String>,
pub uri: Option<String>,
}

22
packages/backend/native-utils/src/model/entity/meta.rs
View file

@ -4,8 +4,6 @@ use super::sea_orm_active_enums::MetaSensitivemediadetectionEnum;
use super::sea_orm_active_enums::MetaSensitivemediadetectionsensitivityEnum;
use sea_orm::entity::prelude::*;
use super::newtype::StringVec;
#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Default)]
#[sea_orm(table_name = "meta")]
pub struct Model {
@ -25,11 +23,11 @@ pub struct Model {
pub disable_global_timeline: bool,
#[sea_orm(column_name = "useStarForReactionFallback")]
pub use_star_for_reaction_fallback: bool,
pub langs: StringVec,
pub langs: Vec<String>,
#[sea_orm(column_name = "hiddenTags")]
pub hidden_tags: StringVec,
pub hidden_tags: Vec<String>,
#[sea_orm(column_name = "blockedHosts")]
pub blocked_hosts: StringVec,
pub blocked_hosts: Vec<String>,
#[sea_orm(column_name = "mascotImageUrl")]
pub mascot_image_url: Option<String>,
#[sea_orm(column_name = "bannerUrl")]
@ -90,7 +88,7 @@ pub struct Model {
#[sea_orm(column_name = "discordClientSecret")]
pub discord_client_secret: Option<String>,
#[sea_orm(column_name = "pinnedUsers")]
pub pinned_users: StringVec,
pub pinned_users: Vec<String>,
#[sea_orm(column_name = "ToSUrl")]
pub to_s_url: Option<String>,
#[sea_orm(column_name = "repositoryUrl")]
@ -130,7 +128,7 @@ pub struct Model {
#[sea_orm(column_name = "objectStorageSetPublicRead")]
pub object_storage_set_public_read: bool,
#[sea_orm(column_name = "pinnedPages")]
pub pinned_pages: StringVec,
pub pinned_pages: Vec<String>,
#[sea_orm(column_name = "backgroundImageUrl")]
pub background_image_url: Option<String>,
#[sea_orm(column_name = "logoImageUrl")]
@ -140,7 +138,7 @@ pub struct Model {
#[sea_orm(column_name = "objectStorageS3ForcePathStyle")]
pub object_storage_s3_force_path_style: bool,
#[sea_orm(column_name = "allowedHosts")]
pub allowed_hosts: Option<StringVec>,
pub allowed_hosts: Option<Vec<String>>,
#[sea_orm(column_name = "secureMode")]
pub secure_mode: Option<bool>,
#[sea_orm(column_name = "privateMode")]
@ -170,13 +168,13 @@ pub struct Model {
#[sea_orm(column_name = "enableActiveEmailValidation")]
pub enable_active_email_validation: bool,
#[sea_orm(column_name = "customMOTD")]
pub custom_motd: StringVec,
pub custom_motd: Vec<String>,
#[sea_orm(column_name = "customSplashIcons")]
pub custom_splash_icons: StringVec,
pub custom_splash_icons: Vec<String>,
#[sea_orm(column_name = "disableRecommendedTimeline")]
pub disable_recommended_timeline: bool,
#[sea_orm(column_name = "recommendedInstances")]
pub recommended_instances: StringVec,
pub recommended_instances: Vec<String>,
#[sea_orm(column_name = "enableGuestTimeline")]
pub enable_guest_timeline: bool,
#[sea_orm(column_name = "defaultReaction")]
@ -186,7 +184,7 @@ pub struct Model {
#[sea_orm(column_name = "libreTranslateApiKey")]
pub libre_translate_api_key: Option<String>,
#[sea_orm(column_name = "silencedHosts")]
pub silenced_hosts: StringVec,
pub silenced_hosts: Vec<String>,
#[sea_orm(column_name = "experimentalFeatures", column_type = "JsonBinary")]
pub experimental_features: Json,
#[sea_orm(column_name = "enableServerMachineStats")]

51
packages/backend/native-utils/src/model/entity/newtype/macros.rs
View file

@ -1,51 +0,0 @@
#[macro_export]
macro_rules! impl_json_newtype {
($a:tt) => {
impl From<$a> for Value {
fn from(source: $a) -> Self {
Value::Json(serde_json::to_value(source).ok().map(Box::new))
}
}
impl TryGetable for $a {
fn try_get_by<I: sea_orm::ColIdx>(
res: &QueryResult,
idx: I,
) -> Result<Self, TryGetError> {
let json_value: serde_json::Value =
res.try_get_by(idx).map_err(TryGetError::DbErr)?;
serde_json::from_value(json_value)
.map_err(|e| TryGetError::DbErr(DbErr::Json(e.to_string())))
}
}
impl sea_query::ValueType for $a {
fn try_from(v: Value) -> Result<Self, sea_query::ValueTypeErr> {
match v {
Value::Json(Some(x)) => Ok($a(
serde_json::from_value(*x).map_err(|_| sea_query::ValueTypeErr)?
)),
_ => Err(sea_query::ValueTypeErr),
}
}
fn type_name() -> String {
stringify!($a).to_owned()
}
fn array_type() -> sea_query::ArrayType {
sea_query::ArrayType::Json
}
fn column_type() -> sea_query::ColumnType {
sea_query::ColumnType::JsonBinary
}
}
impl sea_query::Nullable for $a {
fn null() -> Value {
Value::Json(None)
}
}
};
}

30
packages/backend/native-utils/src/model/entity/newtype/mod.rs
View file

@ -1,30 +0,0 @@
mod macros;
use cfg_if::cfg_if;
use derive_more::{From, Into};
use sea_orm::{sea_query, DbErr, QueryResult, TryGetError, TryGetable, Value};
use serde::{Deserialize, Serialize};
use crate::impl_json_newtype;
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, From, Into, Default)]
pub struct JsonKeyword(pub Vec<Vec<String>>);
impl_json_newtype!(JsonKeyword);
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, From, Into, Default)]
pub struct JsonStringVec(pub Vec<String>);
impl_json_newtype!(JsonStringVec);
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, From, Into, Default)]
pub struct JsonI32Vec(pub Vec<i32>);
impl_json_newtype!(JsonI32Vec);
cfg_if! {
if #[cfg(feature = "noarray")] {
pub type StringVec = JsonStringVec;
pub type I32Vec = JsonI32Vec;
} else {
pub type StringVec = Vec<String>;
pub type I32Vec = Vec<i32>;
}
}

14
packages/backend/native-utils/src/model/entity/note.rs
View file

@ -3,8 +3,6 @@
use super::sea_orm_active_enums::NoteVisibilityEnum;
use sea_orm::entity::prelude::*;
use super::newtype::StringVec;
#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Default)]
#[sea_orm(table_name = "note")]
pub struct Model {
@ -34,16 +32,16 @@ pub struct Model {
pub uri: Option<String>,
pub score: i32,
#[sea_orm(column_name = "fileIds")]
pub file_ids: StringVec,
pub file_ids: Vec<String>,
#[sea_orm(column_name = "attachedFileTypes")]
pub attached_file_types: StringVec,
pub attached_file_types: Vec<String>,
#[sea_orm(column_name = "visibleUserIds")]
pub visible_user_ids: StringVec,
pub mentions: StringVec,
pub visible_user_ids: Vec<String>,
pub mentions: Vec<String>,
#[sea_orm(column_name = "mentionedRemoteUsers", column_type = "Text")]
pub mentioned_remote_users: String,
pub emojis: StringVec,
pub tags: StringVec,
pub emojis: Vec<String>,
pub tags: Vec<String>,
#[sea_orm(column_name = "hasPoll")]
pub has_poll: bool,
#[sea_orm(column_name = "userHost")]

4
packages/backend/native-utils/src/model/entity/note_edit.rs
View file

@ -2,8 +2,6 @@
use sea_orm::entity::prelude::*;
use super::newtype::StringVec;
#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Default)]
#[sea_orm(table_name = "note_edit")]
pub struct Model {
@ -15,7 +13,7 @@ pub struct Model {
pub text: Option<String>,
pub cw: Option<String>,
#[sea_orm(column_name = "fileIds")]
pub file_ids: StringVec,
pub file_ids: Vec<String>,
#[sea_orm(column_name = "updatedAt")]
pub updated_at: DateTimeWithTimeZone,
}

4
packages/backend/native-utils/src/model/entity/page.rs
View file

@ -3,8 +3,6 @@
use super::sea_orm_active_enums::PageVisibilityEnum;
use sea_orm::entity::prelude::*;
use super::newtype::StringVec;
#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Default)]
#[sea_orm(table_name = "page")]
pub struct Model {
@ -30,7 +28,7 @@ pub struct Model {
pub variables: Json,
pub visibility: PageVisibilityEnum,
#[sea_orm(column_name = "visibleUserIds")]
pub visible_user_ids: StringVec,
pub visible_user_ids: Vec<String>,
#[sea_orm(column_name = "likedCount")]
pub liked_count: i32,
#[sea_orm(column_name = "hideTitleWhenPinned")]

6
packages/backend/native-utils/src/model/entity/poll.rs
View file

@ -3,8 +3,6 @@
use super::sea_orm_active_enums::PollNotevisibilityEnum;
use sea_orm::entity::prelude::*;
use super::newtype::{I32Vec, StringVec};
#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Default)]
#[sea_orm(table_name = "poll")]
pub struct Model {
@ -13,8 +11,8 @@ pub struct Model {
#[sea_orm(column_name = "expiresAt")]
pub expires_at: Option<DateTimeWithTimeZone>,
pub multiple: bool,
pub choices: StringVec,
pub votes: I32Vec,
pub choices: Vec<String>,
pub votes: Vec<i32>,
#[sea_orm(column_name = "noteVisibility")]
pub note_visibility: PollNotevisibilityEnum,
#[sea_orm(column_name = "userId")]

4
packages/backend/native-utils/src/model/entity/registry_item.rs
View file

@ -2,8 +2,6 @@
use sea_orm::entity::prelude::*;
use super::newtype::StringVec;
#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Default)]
#[sea_orm(table_name = "registry_item")]
pub struct Model {
@ -16,7 +14,7 @@ pub struct Model {
#[sea_orm(column_name = "userId")]
pub user_id: String,
pub key: String,
pub scope: StringVec,
pub scope: Vec<String>,
pub domain: Option<String>,
#[sea_orm(column_type = "JsonBinary", nullable)]
pub value: Option<Json>,

5
packages/backend/native-utils/src/model/entity/sea_orm_active_enums.rs
View file

@ -1,9 +1,12 @@
//! `SeaORM` Entity. Generated by sea-orm-codegen 0.11.3
use sea_orm::entity::prelude::*;
use parse_display::Display;
#[derive(Debug, Clone, PartialEq, Eq, EnumIter, DeriveActiveEnum, Default)]
#[derive(Debug, Clone, PartialEq, Eq, EnumIter, DeriveActiveEnum, Default, Display)]
#[sea_orm(rs_type = "String", db_type = "Enum", enum_name = "antenna_src_enum")]
#[display(style = "camelCase")]
#[display("'{}'")]
pub enum AntennaSrcEnum {
#[default]
#[sea_orm(string_value = "all")]

6
packages/backend/native-utils/src/model/entity/user.rs
View file

@ -2,8 +2,6 @@
use sea_orm::entity::prelude::*;
use super::newtype::StringVec;
#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Default)]
#[sea_orm(table_name = "user")]
pub struct Model {
@ -29,7 +27,7 @@ pub struct Model {
pub avatar_id: Option<String>,
#[sea_orm(column_name = "bannerId", unique)]
pub banner_id: Option<String>,
pub tags: StringVec,
pub tags: Vec<String>,
#[sea_orm(column_name = "isSuspended")]
pub is_suspended: bool,
#[sea_orm(column_name = "isSilenced")]
@ -44,7 +42,7 @@ pub struct Model {
pub is_admin: bool,
#[sea_orm(column_name = "isModerator")]
pub is_moderator: bool,
pub emojis: StringVec,
pub emojis: Vec<String>,
pub host: Option<String>,
pub inbox: Option<String>,
#[sea_orm(column_name = "sharedInbox")]

4
packages/backend/native-utils/src/model/entity/user_profile.rs
View file

@ -3,8 +3,6 @@
use super::sea_orm_active_enums::UserProfileFfvisibilityEnum;
use sea_orm::entity::prelude::*;
use super::newtype::StringVec;
#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Default)]
#[sea_orm(table_name = "user_profile")]
pub struct Model {
@ -55,7 +53,7 @@ pub struct Model {
#[sea_orm(column_name = "mutedWords", column_type = "JsonBinary")]
pub muted_words: Json,
#[sea_orm(column_name = "mutingNotificationTypes")]
pub muting_notification_types: StringVec,
pub muting_notification_types: Vec<String>,
#[sea_orm(column_name = "noCrawle")]
pub no_crawle: bool,
#[sea_orm(column_name = "receiveAnnouncementEmail")]

4
packages/backend/native-utils/src/model/entity/webhook.rs
View file

@ -2,8 +2,6 @@
use sea_orm::entity::prelude::*;
use super::newtype::StringVec;
#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Default)]
#[sea_orm(table_name = "webhook")]
pub struct Model {
@ -14,7 +12,7 @@ pub struct Model {
#[sea_orm(column_name = "userId")]
pub user_id: String,
pub name: String,
pub on: StringVec,
pub on: Vec<String>,
pub url: String,
pub secret: String,
pub active: bool,

2
packages/backend/native-utils/src/model/mod.rs
View file

@ -1,4 +1,4 @@
pub mod entity;
pub mod error;
pub mod repository;
// pub mod repository;
pub mod schema;

2
packages/backend/native-utils/src/model/repository.rs
View file

@ -1,5 +1,3 @@
pub mod antenna;
use async_trait::async_trait;
use schemars::JsonSchema;

56
packages/backend/native-utils/src/model/repository/antenna.rs
View file

@ -1,56 +0,0 @@
use async_trait::async_trait;
use cfg_if::cfg_if;
use sea_orm::EntityTrait;
use crate::database;
use crate::model::entity::{antenna, user_group_joining};
use crate::model::error::Error;
use crate::model::schema::Antenna;
use super::macros::impl_pack_by_id;
use super::Repository;
#[async_trait]
impl Repository<Antenna> for antenna::Model {
async fn pack(self) -> Result<Antenna, Error> {
let db = database::get_database()?;
let user_group_joining = match self.user_group_joining_id {
None => None,
Some(id) => user_group_joining::Entity::find_by_id(id).one(db).await?,
};
let user_group_id = match user_group_joining {
None => None,
Some(m) => Some(m.user_group_id),
};
cfg_if! {
if #[cfg(feature = "napi")] {
let created_at: String = self.created_at.to_rfc3339();
} else {
let created_at: chrono::DateTime<chrono::Utc> = self.created_at.into();
}
}
Ok(Antenna {
id: self.id,
created_at,
name: self.name,
keywords: self.keywords.into(),
exclude_keywords: self.exclude_keywords.into(),
src: self.src.try_into()?,
user_list_id: self.user_list_id,
user_group_id,
users: self.users,
instances: self.instances.into(),
case_sensitive: self.case_sensitive,
notify: self.notify,
with_replies: self.with_replies,
with_file: self.with_file,
has_unread_note: false,
})
}
async fn pack_by_id(id: String) -> Result<Antenna, Error> {
impl_pack_by_id!(antenna::Entity, id)
}
}

215
packages/backend/native-utils/tests/common.rs
View file

@ -1,215 +0,0 @@
#![cfg(not(feature = "napi"))]
mod model;
use chrono::Utc;
use native_utils::database;
use native_utils::model::entity;
use native_utils::model::entity::sea_orm_active_enums::AntennaSrcEnum;
use native_utils::util::{
id::{create_id, init_id},
random::gen_string,
};
use sea_orm::{
sea_query::TableCreateStatement, ActiveModelTrait, ConnectionTrait, DbBackend, DbConn, DbErr,
EntityTrait, IntoActiveModel, TransactionTrait,
};
/// Insert predefined entries in the database.
async fn prepare() {
database::init_database("sqlite::memory:")
.await
.expect("Unable to initialize database connection");
let db = database::get_database().expect("Unable to get database connection from pool");
setup_schema(db).await;
setup_model(db).await;
}
/// Setup schemas in the database.
async fn setup_schema(db: &DbConn) {
let schema = sea_orm::Schema::new(DbBackend::Sqlite);
let mut stmts: Vec<TableCreateStatement> = Vec::new();
macro_rules! create_table_statement {
($a:tt) => {
stmts.push(schema.create_table_from_entity(entity::$a::Entity).if_not_exists().to_owned());
};
($a:tt, $($b:tt),+) => {
create_table_statement!($a);
create_table_statement!($($b),+);
};
}
create_table_statement!(
abuse_user_report,
access_token,
ad,
announcement_read,
announcement,
antenna,
app,
attestation_challenge,
auth_session,
blocking,
channel_following,
channel_note_pining,
channel,
clip_note,
clip,
drive_file,
drive_folder,
emoji,
following,
follow_request,
gallery_like,
gallery_post,
hashtag,
instance,
messaging_message,
meta,
migrations,
moderation_log,
muted_note,
muting,
note_edit,
note_favorite,
note_reaction,
note,
note_thread_muting,
note_unread,
note_watching,
notification,
page_like,
page,
password_reset_request,
poll,
poll_vote,
promo_note,
promo_read,
registration_ticket,
registry_item,
relay,
renote_muting,
signin,
sw_subscription,
used_username,
user_group_invitation,
user_group_invite,
user_group_joining,
user_group,
user_ip,
user_keypair,
user_list_joining,
user_list,
user_note_pining,
user_pending,
user_profile,
user_publickey,
user,
user_security_key,
webhook
);
db.transaction::<_, (), DbErr>(|txn| {
Box::pin(async move {
for stmt in stmts {
txn.execute(txn.get_database_backend().build(&stmt)).await?;
}
Ok(())
})
})
.await
.expect("Unable to setup schemas");
}
/// Delete all entries in the database.
async fn cleanup() {
let db = database::get_database().expect("Unable to get database connection from pool");
db.transaction::<_, (), DbErr>(|txn| {
Box::pin(async move {
entity::user::Entity::delete_many().exec(txn).await.unwrap();
entity::antenna::Entity::delete_many()
.exec(txn)
.await
.unwrap();
Ok(())
})
})
.await
.expect("Unable to delete predefined models");
}
async fn setup_model(db: &DbConn) {
init_id(16, "");
db.transaction::<_, (), DbErr>(|txn| {
Box::pin(async move {
let user_id = create_id(0).unwrap();
let name = "Alice";
let user_model = entity::user::Model {
id: user_id.to_owned(),
created_at: Utc::now().into(),
username: name.to_lowercase(),
username_lower: name.to_lowercase(),
name: Some(name.to_string()),
token: Some(gen_string(16)),
is_admin: true,
..Default::default()
};
user_model
.into_active_model()
.reset_all()
.insert(txn)
.await?;
let antenna_model = entity::antenna::Model {
id: create_id(0).unwrap(),
created_at: Utc::now().into(),
user_id: user_id.to_owned(),
name: "Alice Antenna".to_string(),
src: AntennaSrcEnum::All,
keywords: vec![
vec!["foo".to_string(), "bar".to_string()],
vec!["foobar".to_string()],
]
.into(),
exclude_keywords: vec![
vec!["abc".to_string()],
vec!["def".to_string(), "ghi".to_string()],
]
.into(),
notify: true,
case_sensitive: true,
..Default::default()
};
antenna_model
.into_active_model()
.reset_all()
.insert(txn)
.await?;
let note_model = entity::note::Model {
id: create_id(0).unwrap(),
created_at: Utc::now().into(),
text: Some("Testing 123".to_string()),
user_id: user_id.to_owned(),
..Default::default()
};
note_model
.into_active_model()
.reset_all()
.insert(txn)
.await?;
Ok(())
})
})
.await
.expect("Unable to setup predefined models");
}
mod int_test {
use super::{cleanup, prepare};
#[tokio::test]
async fn can_prepare_and_cleanup() {
prepare().await;
cleanup().await;
}
}

1
packages/backend/native-utils/tests/model/mod.rs
View file

@ -1 +0,0 @@
mod repository;

1
packages/backend/native-utils/tests/model/repository.rs
View file

@ -1 +0,0 @@
mod antenna;

98
packages/backend/native-utils/tests/model/repository/antenna.rs
View file

@ -1,98 +0,0 @@
mod int_test {
use native_utils::{database, model};
use model::{
entity::{antenna, user},
repository::Repository,
schema,
};
use pretty_assertions::assert_eq;
use sea_orm::{ColumnTrait, EntityTrait, QueryFilter};
use crate::{cleanup, prepare};
#[tokio::test]
async fn can_pack() {
prepare().await;
let db = database::get_database().unwrap();
let alice_antenna = user::Entity::find()
.filter(user::Column::Username.eq("alice"))
.find_also_related(antenna::Entity)
.one(db)
.await
.unwrap()
.expect("alice not found")
.1
.expect("alice's antenna not found");
let packed = alice_antenna
.to_owned()
.pack()
.await
.expect("Unable to pack");
let packed_by_id = antenna::Model::pack_by_id(alice_antenna.id.to_owned())
.await
.expect("Unable to pack");
let result = schema::Antenna {
id: alice_antenna.id,
created_at: alice_antenna.created_at.into(),
name: "Alice Antenna".to_string(),
keywords: vec![
vec!["foo".to_string(), "bar".to_string()],
vec!["foobar".to_string()],
],
exclude_keywords: vec![
vec!["abc".to_string()],
vec!["def".to_string(), "ghi".to_string()],
],
src: schema::AntennaSrc::All,
user_list_id: None,
user_group_id: None,
users: vec![],
instances: vec![],
case_sensitive: true,
notify: true,
with_replies: false,
with_file: false,
has_unread_note: false,
};
assert_eq!(packed, result);
assert_eq!(packed_by_id, result);
cleanup().await;
}
#[tokio::test]
async fn unread_note() {
prepare().await;
let db = database::get_database().unwrap();
let (_, alice_antenna) = user::Entity::find()
.filter(user::Column::Username.eq("alice"))
.find_also_related(antenna::Entity)
.one(db)
.await
.unwrap()
.expect("alice not found");
let alice_antenna = alice_antenna.expect("alice's antenna not found");
let packed = alice_antenna
.to_owned()
.pack()
.await
.expect("Unable to pack");
assert_eq!(packed.has_unread_note, false);
let packed = alice_antenna
.to_owned()
.pack()
.await
.expect("Unable to pack");
assert_eq!(packed.has_unread_note, true);
cleanup().await;
}
}

33
packages/backend/src/models/repositories/antenna.ts
View file

@ -1,14 +1,33 @@
import { db } from "@/db/postgre.js";
import { Antenna } from "@/models/entities/antenna.js";
import {
NativeAntennaSchema,
nativePackAntennaById,
} from "native-utils/built/index.js";
import type { Packed } from "@/misc/schema.js";
import { UserGroupJoinings } from "@/models/index.js";
export const AntennaRepository = db.getRepository(Antenna).extend({
async pack(src: Antenna["id"] | Antenna): Promise<NativeAntennaSchema> {
const id = typeof src === "object" ? src.id : src;
async pack(src: Antenna["id"] | Antenna): Promise<Packed<"Antenna">> {
const antenna =
typeof src === "object" ? src : await this.findOneByOrFail({ id: src });
return await nativePackAntennaById(id);
const userGroupJoining = antenna.userGroupJoiningId
? await UserGroupJoinings.findOneBy({ id: antenna.userGroupJoiningId })
: null;
return {
id: antenna.id,
createdAt: antenna.createdAt.toISOString(),
name: antenna.name,
keywords: antenna.keywords,
excludeKeywords: antenna.excludeKeywords,
src: antenna.src,
userListId: antenna.userListId,
userGroupId: userGroupJoining ? userGroupJoining.userGroupId : null,
users: antenna.users,
instances: antenna.instances,
caseSensitive: antenna.caseSensitive,
notify: antenna.notify,
withReplies: antenna.withReplies,
withFile: antenna.withFile,
hasUnreadNote: false,
};
},
});