Add syncable traits

lazy-supplements-core/src/cache/entity/mod.rs

@@ -1,13 +1,5 @@
-mod multi_address;
 mod peer;
 
-pub use multi_address::{
-    ActiveModel as ActiveMultiAddressModel,
-    Column as MultiAddressColumn,
-    Model as MultiAddressModel,
-    Entity as MultiAddressEntity,
-};
-
 pub use peer::{
     ActiveModel as ActivePeerModel,
     Column as PeerColumn,

lazy-supplements-core/src/cache/entity/multi_address.rs

@@ -1,61 +0,0 @@
-use chrono::Local;
-use sea_orm::entity::{
-    *,
-    prelude::*
-};
-use serde::{Deserialize, Serialize};
-
-
-#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Serialize, Deserialize)]
-#[sea_orm(table_name = "node")]
-pub struct Model {
-    #[sea_orm(primary_key)]
-    pub id: u32,
-    #[sea_orm(indexed)]
-    pub created_at: DateTimeUtc,
-    #[sea_orm(indexed)]
-    pub updated_at: DateTimeUtc,
-    #[sea_orm(indexed)]
-    pub synced_at: Option<DateTimeUtc>,
-    #[sea_orm(indexed)]
-    pub peer_id: String,
-    #[sea_orm(column_type = "Text")]
-    pub note: String,
-}
-
-#[derive(Copy, Clone, Debug, DeriveRelation, EnumIter)]
-pub enum Relation {}
-    
-impl ActiveModelBehavior for ActiveModel {}
-
-impl ActiveModel {
-    pub fn new() -> Self {
-        let timestamp: DateTimeUtc = Local::now().to_utc();
-        Self{
-            created_at: Set(timestamp),
-            updated_at: Set(timestamp),
-            ..Default::default()
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::global::get_or_init_test_cache_database;
-
-    use super::*;
-
-    use libp2p::identity;
-
-     #[tokio::test]
-    async fn check_insert_node() {
-        let db = get_or_init_test_cache_database().await;
-        
-        ActiveModel{
-            peer_id: Set(identity::Keypair::generate_ed25519().public().to_peer_id().to_string()),
-            note: Set("test note".to_owned()),
-            ..ActiveModel::new()
-        }.insert(db).await.unwrap();
-    }
-
-}

lazy-supplements-core/src/cache/entity/peer.rs

@@ -1,13 +1,17 @@
-use chrono::Local;
-use sea_orm::entity::{
-    *,
-    prelude::*
-};
+use std::str::FromStr;
+
+use chrono::{Days, Local};
+use libp2p::{multiaddr, Multiaddr, PeerId};
+use sea_orm::{entity::{
+    prelude::*, *
+}, sea_query};
 use serde::{Deserialize, Serialize};
 
+use crate::data::value::{MultiaddrValue, PeerIdValue};
 
-#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Serialize, Deserialize)]
-#[sea_orm(table_name = "node")]
+
+#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]
+#[sea_orm(table_name = "peer")]
 pub struct Model {
     #[sea_orm(primary_key)]
     pub id: u32,
@@ -16,20 +20,28 @@ pub struct Model {
     #[sea_orm(indexed)]
     pub updated_at: DateTimeUtc,
     #[sea_orm(indexed)]
-    pub peer_id: String,
+    pub expires_at: DateTimeUtc,
+    #[sea_orm(indexed)]
+    pub peer_id: PeerIdValue,
+    #[sea_orm(indexed)]
+    pub address: MultiaddrValue,
 }
 
+
 #[derive(Copy, Clone, Debug, DeriveRelation, EnumIter)]
 pub enum Relation {}
     
 impl ActiveModelBehavior for ActiveModel {}
 
 impl ActiveModel {
-    pub fn new() -> Self {
+    pub fn new(peer_id: PeerId, multiaddr: Multiaddr) -> Self {
         let timestamp: DateTimeUtc = Local::now().to_utc();
         Self{
+            peer_id: Set(PeerIdValue::from(peer_id)),
+            address: Set(MultiaddrValue::from(multiaddr)),
             created_at: Set(timestamp),
             updated_at: Set(timestamp),
+            expires_at: Set(timestamp.checked_add_days(Days::new(30)).unwrap()),
             ..Default::default()
         }
     }
@@ -37,20 +49,25 @@ impl ActiveModel {
 
 #[cfg(test)]
 mod tests {
-    use crate::global::get_or_init_test_cache_database;
+    use std::net::Ipv4Addr;
+
+    use crate::{cache::entity::peer, global::get_or_init_test_cache_database};
 
     use super::*;
 
-    use libp2p::identity;
+    use libp2p::{identity::{self, Keypair}, swarm::handler::multi};
 
      #[tokio::test]
-    async fn check_insert_node() {
+    async fn insert() {
         let db = get_or_init_test_cache_database().await;
-        
-        ActiveModel{
-            peer_id: Set(identity::Keypair::generate_ed25519().public().to_peer_id().to_string()),
-            ..ActiveModel::new()
-        }.insert(db).await.unwrap();
+        let peer_id = Keypair::generate_ed25519().public().to_peer_id();
+        let multiaddr = Multiaddr::empty()
+            .with(Ipv4Addr::new(127,0,0,1).into())
+            .with(multiaddr::Protocol::Tcp(0));
+        let inserted: Model = ActiveModel::new(peer_id.clone(), multiaddr.clone())
+                .insert(db).await.unwrap();
+        assert_eq!(PeerId::from(inserted.peer_id), peer_id);
+        assert_eq!(Multiaddr::from(inserted.address), multiaddr);     
     }
 
 }

lazy-supplements-core/src/cache/migration/m20220101_000001_create_cache_tables.rs

@@ -9,18 +9,16 @@ pub struct Migration;
 impl MigrationTrait for Migration {
     async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
         Peer::up(manager).await?;
-        Address::up(manager).await?;
         Ok(())
     }
 
     async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
         Peer::down(manager).await?;
-        Address::down(manager).await?;
         Ok(())
     }
 }
 
-#[derive(DeriveIden)]
+#[derive(DeriveIden, DeriveMigrationName)]
 enum Peer {
     Table,
     Id,
@@ -28,9 +26,14 @@ enum Peer {
     CreatedAt,
     UpdatedAt,
     ExpiresAt,
+    Address,
 }
 
+static IDX_PEER_ADDRESS: &str = "idx_peer_address";
 static IDX_PEER_PEER_ID: &str = "idx_peer_peer_id";
+static IDX_PEER_CREATED_AT: &str = "idx_peer_created_at";
+static IDX_PEER_UPDATED_AT: &str = "idx_peer_updated_at";
+static IDX_PEER_EXPIRES_AT: &str = "idx_peer_expires_at";
 
 #[async_trait::async_trait]
 impl TableMigration for Peer {
@@ -40,10 +43,11 @@ impl TableMigration for Peer {
                 .table(Self::Table)
                 .if_not_exists()
                 .col(pk_auto(Self::Id))
+                .col(string_len(Self::PeerId, 255))
                 .col(timestamp(Self::CreatedAt))
                 .col(timestamp(Self::UpdatedAt))
                 .col(timestamp(Self::ExpiresAt))
-                .col(string_len_uniq(Self::PeerId, 255))
+                .col(text_uniq(Self::Address))
                 .to_owned()
         ).await?;
         manager.create_index(
@@ -53,53 +57,32 @@ impl TableMigration for Peer {
                 .col(Self::PeerId)
                 .to_owned()
         ).await?;
-        Ok(())
-    }
-    async fn down<'a>(manager: &'a SchemaManager<'a>) -> Result<(), DbErr>{
-        manager.drop_table(Table::drop().table(Self::Table).to_owned()).await
-    }
-}
-
-#[derive(DeriveIden, DeriveMigrationName)]
-enum Address {
-    Table,
-    Id,
-    PeerId,
-    CreatedAt,
-    UpdatedAt,
-    ExpiresAt,
-    MultiAddress,
-}
-
-static IDX_ADDRESS_MULTIADDRESS: &str = "idx_address_multiaddress";
-static FK_ADDRESS_PEER: &str = "fk_address_peer";
-
-#[async_trait::async_trait]
-impl TableMigration for Address {
-    async fn up<'a>(manager: &'a SchemaManager<'a>) -> Result<(), DbErr> {
-        manager.create_table(
-            Table::create()
+        manager.create_index(
+            Index::create()
+                .name(IDX_PEER_ADDRESS)
                 .table(Self::Table)
-                .if_not_exists()
-                .col(pk_auto(Self::Id))
-                .col(integer(Self::PeerId))
-                .col(timestamp(Self::CreatedAt))
-                .col(timestamp(Self::UpdatedAt))
-                .col(timestamp(Self::ExpiresAt))
-                .col(text_uniq(Self::MultiAddress))
-                .foreign_key(
-                    ForeignKey::create()
-                        .name(FK_ADDRESS_PEER)
-                        .from(Self::Table, Self::PeerId)
-                        .to(Peer::Table, Peer::Id)
-                )
+                .col(Self::Address)
                 .to_owned()
         ).await?;
         manager.create_index(
             Index::create()
-                .name(IDX_ADDRESS_MULTIADDRESS)
+                .name(IDX_PEER_CREATED_AT)
                 .table(Self::Table)
-                .col(Self::MultiAddress)
+                .col(Self::CreatedAt)
+                .to_owned()
+        ).await?;
+        manager.create_index(
+            Index::create()
+                .name(IDX_PEER_UPDATED_AT)
+                .table(Self::Table)
+                .col(Self::UpdatedAt)
+                .to_owned()
+        ).await?;
+        manager.create_index(
+            Index::create()
+                .name(IDX_PEER_EXPIRES_AT)
+                .table(Self::Table)
+                .col(Self::ExpiresAt)
                 .to_owned()
         ).await?;
         Ok(())

lazy-supplements-core/src/config/storage.rs

@@ -2,6 +2,9 @@ use std::path::PathBuf;
 
 #[cfg(feature="desktop")]
 use clap::Args;
+
+#[cfg(any(test, feature="test"))]
+use tempfile::tempdir;
 use crate::{config::{ConfigError, PartialConfig}};
 use libp2p::mdns::Config;
 use serde::{Deserialize, Serialize};
@@ -30,8 +33,9 @@ impl StorageConfig {
 #[cfg(any(test, feature="test"))]
 impl TestDefault for StorageConfig {
     fn test_default() -> Self {
-        let temp_path = tempfile::NamedTempFile::new().unwrap().into_temp_path().keep().unwrap();
-        Self { data_directory: temp_path.clone(), cache_directory: temp_path }
+        
+        let temp_dir = tempdir().unwrap().keep();
+        Self { data_directory: temp_dir.clone(), cache_directory: temp_dir }
     }
 }
 

lazy-supplements-core/src/data/entity/mod.rs

@@ -1,11 +1,11 @@
-mod node;
+mod trusted_peer;
 mod record_deletion;
 
-pub use node::{
-    ActiveModel as NodeActiveModel,
-    Column as NodeColumn,
-    Entity as NodeEntity,
-    Model as NodeModel,
+pub use trusted_peer::{
+    ActiveModel as TrustedPeerActiveModel,
+    Column as TrustedPeerColumn,
+    Entity as TrustedPeerEntity,
+    Model as TrustedPeerModel,
 };
 
 pub use record_deletion::{

lazy-supplements-core/src/data/entity/trusted_peer.rs

@@ -5,9 +5,11 @@ use sea_orm::entity::{
 };
 use serde::{Deserialize, Serialize};
 
+use crate::data::value::PeerIdValue;
+
 
 #[derive(Clone, Debug, PartialEq, DeriveEntityModel, Serialize, Deserialize)]
-#[sea_orm(table_name = "node")]
+#[sea_orm(table_name = "trusted_peer")]
 pub struct Model {
     #[sea_orm(primary_key, auto_increment = false)]
     pub id: Uuid,
@@ -18,9 +20,10 @@ pub struct Model {
     #[sea_orm(indexed)]
     pub synced_at: Option<DateTimeUtc>,
     #[sea_orm(indexed)]
-    pub peer_id: String,
+    pub peer_id: PeerIdValue,
     #[sea_orm(column_type = "Text")]
     pub note: String,
+    pub is_prefered: bool,
 }
 
 #[derive(Copy, Clone, Debug, DeriveRelation, EnumIter)]
@@ -46,14 +49,14 @@ mod tests {
 
     use super::*;
 
-    use libp2p::identity;
+    use libp2p::{identity, PeerId};
 
      #[tokio::test]
     async fn check_insert_node() {
         let db = get_or_init_test_data_database().await;
         
         ActiveModel{
-            peer_id: Set(identity::Keypair::generate_ed25519().public().to_peer_id().to_string()),
+            peer_id: Set(PeerIdValue::from(PeerId::random())),
             note: Set("test note".to_owned()),
             ..ActiveModel::new()
         }.insert(db).await.unwrap();

lazy-supplements-core/src/data/migration/m20220101_000001_create_main_tables.rs

@@ -8,20 +8,20 @@ pub struct Migration;
 #[async_trait::async_trait]
 impl MigrationTrait for Migration {
     async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
-        Node::up(manager).await?;
+        TrustedPeer::up(manager).await?;
         RecordDeletion::up(manager).await?;
         Ok(())
     }
 
     async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
-        Node::down(manager).await?;
+        TrustedPeer::down(manager).await?;
         RecordDeletion::down(manager).await?;
         Ok(())
     }
 }
 
 #[derive(DeriveIden)]
-enum Node {
+enum TrustedPeer {
     Table,
     Id,
     CreatedAt,
@@ -29,10 +29,11 @@ enum Node {
     SyncedAt,
     PeerId,
     Note,
+    IsPrefered,
 }
 
 #[async_trait::async_trait]
-impl TableMigration for Node {
+impl TableMigration for TrustedPeer {
     async fn up<'a>(manager: &'a SchemaManager<'a>) -> Result<(), DbErr> {
         manager.create_table(
             Table::create()
@@ -44,6 +45,7 @@ impl TableMigration for Node {
                 .col(timestamp_null(Self::SyncedAt))
                 .col(string_len(Self::PeerId, 255))
                 .col(text(Self::Note))
+                .col(boolean(Self::IsPrefered))
                 .to_owned()
         ).await?;
         Ok(())

lazy-supplements-core/src/data/mod.rs

@@ -1,2 +1,4 @@
 pub mod entity;
-pub mod migration;
+pub mod migration;
+pub mod syncable;
+pub mod value;

lazy-supplements-core/src/data/syncable.rs

@@ -0,0 +1,64 @@
+use sea_orm::{*, prelude::*, query::*};
+
+pub trait SyncableModel: ModelTrait<Entity = Self::SyncableEntity> {
+    type SyncableEntity: SyncableEntity<SyncableModel = Self>;
+    fn get_updated_at(&self) -> DateTimeUtc;
+    fn get_uuid(&self) -> Uuid;
+}
+
+pub trait SyncableEntity: EntityTrait<
+    Model = Self::SyncableModel,
+    ActiveModel = Self::SyncableActiveModel,
+    Column = Self::SyncableColumn,
+>{
+    type SyncableModel: SyncableModel<SyncableEntity = Self> + FromQueryResult;
+    type SyncableActiveModel: SyncableActiveModel<SyncableEntity= Self>;
+    type SyncableColumn: SyncableColumn;
+
+    async fn get_updated_after(date: DateTimeUtc, db: &DatabaseConnection) -> Result<Vec<<Self as EntityTrait>::Model>, SyncableError> {
+        let result: Vec<Self::SyncableModel> = <Self as EntityTrait>::find()
+            .filter(Self::SyncableColumn::updated_at().gte(date))
+            .all(db)
+            .await.unwrap();
+        Ok(result)
+    }
+    fn apply_updated(models: Vec<<Self as EntityTrait>::Model>, db: &DatabaseConnection) {
+        todo!()
+    }
+}
+
+pub trait SyncableActiveModel: ActiveModelTrait<Entity = Self::SyncableEntity> {
+    
+    type SyncableEntity: SyncableEntity<SyncableActiveModel = Self>;
+    fn get_uuid(&self) -> Option<Uuid>;
+    fn get_updated_at(&self) -> Option<DateTimeUtc>;
+    fn try_merge(&mut self, other: <Self::SyncableEntity as SyncableEntity>::SyncableModel) -> Result<(), SyncableError> {
+        if self.get_uuid().ok_or(SyncableError::MissingField("uuid"))? != other.get_uuid() {
+            return Err(SyncableError::MismatchUuid)
+        }
+        if self.get_updated_at().ok_or(SyncableError::MissingField("updated_at"))? < other.get_updated_at() {
+            for column in <<<Self as ActiveModelTrait>::Entity as EntityTrait>::Column as Iterable>::iter() {
+                self.take(column).set_if_not_equals(other.get(column));
+            }
+        }
+        Ok(())
+    }
+
+}
+
+pub trait SyncableColumn: ColumnTrait {
+    fn is_uuid(&self) -> bool;
+    fn is_updated_at(&self) -> bool;
+    fn updated_at() -> Self;
+    fn should_not_sync(&self);
+}
+
+
+#[derive(Debug, thiserror::Error)]
+pub enum SyncableError {
+    #[error("Invalid UUID")]
+    MismatchUuid,
+    #[error("mandatory field {0} is missing")]
+    MissingField(&'static str),
+    
+}

lazy-supplements-core/src/data/value/mod.rs

@@ -0,0 +1,5 @@
+mod multiaddr;
+mod peer_id;
+
+pub use multiaddr::MultiaddrValue;
+pub use peer_id::PeerIdValue;

lazy-supplements-core/src/data/value/multiaddr.rs

@@ -0,0 +1,68 @@
+use std::str::FromStr;
+
+use libp2p::Multiaddr;
+use sea_orm::{sea_query::ValueTypeErr, DbErr};
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
+pub struct MultiaddrValue(Multiaddr);
+
+impl From<Multiaddr> for MultiaddrValue {
+    fn from(source: Multiaddr) -> Self {
+        Self(source)
+    }
+}
+impl From<MultiaddrValue> for Multiaddr {
+    fn from(source: MultiaddrValue) -> Self {
+        source.0
+    }
+}
+
+impl From<MultiaddrValue> for sea_orm::Value {
+    fn from(value: MultiaddrValue) -> Self {
+        Self::from(value.0.to_string())
+    }
+}
+
+impl sea_orm::TryGetable for MultiaddrValue {
+    fn try_get_by<I: sea_orm::ColIdx>(res: &sea_orm::QueryResult, idx: I)
+        -> std::result::Result<Self, sea_orm::TryGetError> {
+        match <String as sea_orm::TryGetable>::try_get_by(res, idx){
+            Ok(x) => match Multiaddr::from_str(&x) {
+                Ok(y) => Ok(Self(y)),
+                Err(_) => Err(DbErr::Type("Multiaddr".to_string()).into()),
+            },
+            Err(x) => Err(x),
+        }
+    }
+}
+
+impl sea_orm::sea_query::ValueType for MultiaddrValue {
+    fn try_from(v: sea_orm::Value) -> std::result::Result<Self, sea_orm::sea_query::ValueTypeErr> {
+        match <String as sea_orm::sea_query::ValueType>::try_from(v) {
+            Ok(x) => match Multiaddr::from_str(&x) {
+                Ok(y) => Ok(Self(y)),
+                Err(_) => Err(ValueTypeErr{}),
+            },
+            Err(e) => Err(e)
+        }
+    }
+
+    fn type_name() -> std::string::String {
+        stringify!(MultiaddrValue).to_owned()
+    }
+
+    fn array_type() -> sea_orm::sea_query::ArrayType {
+        sea_orm::sea_query::ArrayType::String
+    }
+
+    fn column_type() -> sea_orm::sea_query::ColumnType {
+        sea_orm::sea_query::ColumnType::Text
+    }
+}
+
+impl sea_orm::sea_query::Nullable for MultiaddrValue {
+    fn null() -> sea_orm::Value {
+        <String as sea_orm::sea_query::Nullable>::null()
+    }
+}

lazy-supplements-core/src/data/value/peer_id.rs

@@ -0,0 +1,120 @@
+use std::str::FromStr;
+
+use libp2p::PeerId;
+use sea_orm::{sea_query::ValueTypeErr, DbErr};
+use serde::{Deserialize, Serialize};
+
+use crate::error::Error;
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct PeerIdValue(PeerId);
+
+impl<'de> Deserialize<'de> for PeerIdValue {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+        where
+            D: serde::Deserializer<'de> {
+        Self::from_str(&String::deserialize(deserializer)?).or(Err(<D::Error as serde::de::Error>::custom("fail to parse PeerId")))
+    
+    }
+}
+
+impl Serialize for PeerIdValue {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer {
+        serializer.serialize_str(&self.0.to_string())
+    }
+}
+
+impl FromStr for PeerIdValue{
+    type Err = libp2p::identity::ParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(Self(PeerId::from_str(s)?))
+    }
+}
+
+impl ToString for PeerIdValue {
+    fn to_string(&self) -> String {
+        self.0.to_string()
+    }
+}
+
+impl From<PeerId> for PeerIdValue {
+    fn from(source: PeerId) -> Self {
+        Self(source)
+    }
+}
+impl From<PeerIdValue> for PeerId {
+    fn from(source: PeerIdValue) -> Self {
+        source.0
+    }
+}
+
+impl From<PeerIdValue> for sea_orm::Value {
+    fn from(value: PeerIdValue) -> Self {
+        Self::from(value.0.to_string())
+    }
+}
+
+impl sea_orm::TryGetable for PeerIdValue {
+    fn try_get_by<I: sea_orm::ColIdx>(res: &sea_orm::QueryResult, idx: I)
+        -> std::result::Result<Self, sea_orm::TryGetError> {
+        match <String as sea_orm::TryGetable>::try_get_by(res, idx){
+            Ok(x) => match PeerId::from_str(&x) {
+                Ok(y) => Ok(Self(y)),
+                Err(_) => Err(DbErr::Type("PeerId".to_string()).into()),
+            },
+            Err(x) => Err(x),
+        }
+    }
+}
+
+impl sea_orm::sea_query::ValueType for PeerIdValue {
+    fn try_from(v: sea_orm::Value) -> std::result::Result<Self, sea_orm::sea_query::ValueTypeErr> {
+        match <String as sea_orm::sea_query::ValueType>::try_from(v) {
+            Ok(x) => match PeerId::from_str(&x) {
+                Ok(y) => Ok(Self(y)),
+                Err(_) => Err(ValueTypeErr{}),
+            },
+            Err(e) => Err(e)
+        }
+    }
+
+    fn type_name() -> std::string::String {
+        stringify!(PeerIdValue).to_owned()
+    }
+
+    fn array_type() -> sea_orm::sea_query::ArrayType {
+        sea_orm::sea_query::ArrayType::String
+    }
+
+    fn column_type() -> sea_orm::sea_query::ColumnType {
+        sea_orm::sea_query::ColumnType::Text
+    }
+}
+
+impl sea_orm::sea_query::Nullable for PeerIdValue {
+    fn null() -> sea_orm::Value {
+        <String as sea_orm::sea_query::Nullable>::null()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::tests::{test_cbor_serialize_deserialize, test_toml_serialize_deserialize};
+
+    use super::*;
+
+    #[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
+    struct PeerIdValueWrapper {
+        content: PeerIdValue
+
+    }
+    #[test]
+    fn test_serialize_deserialize() {
+        let peer_id= PeerIdValueWrapper{content: PeerIdValue::from(PeerId::random())};
+        let x = toml::to_string(&peer_id).unwrap();
+        assert_eq!(peer_id.content, toml::from_str::<PeerIdValueWrapper>(&x).unwrap().content)
+    }
+}

lazy-supplements-core/src/p2p/mod.rs

@@ -40,10 +40,8 @@ impl Event {
                             match PeerEntity::find().filter(PeerColumn::PeerId.contains(&peer.0.to_string())).one(CACHE_DATABASE_CONNECTION.get()).await {
                                 Ok(_) => {}
                                 Err(_) => {
-                                    ActivePeerModel{
-                                        peer_id: Set(peer.0.to_string()),
-                                        ..ActivePeerModel::new()
-                                    }.insert(CACHE_DATABASE_CONNECTION.get()).await;
+                                    ActivePeerModel::new(peer.0.clone(), peer.1.clone())
+                                        .insert(CACHE_DATABASE_CONNECTION.get()).await;
                                 }
                             }
                         }

lazy-supplements-core/src/tests.rs

@@ -1,5 +1,7 @@
 use std::{path::PathBuf, sync::LazyLock};
 
+use sea_orm::{sea_query::{FromValueTuple, IntoValueTuple, ValueType}, ActiveModelBehavior, ActiveModelTrait, ColumnTrait, Condition, DatabaseConnection, EntityTrait, IntoActiveModel, ModelTrait, PrimaryKeyToColumn, PrimaryKeyTrait, Value};
+use sea_orm::QueryFilter;
 use tempfile::TempDir;
 use crate::{ config::PartialConfig, message::Message};
 
@@ -43,4 +45,4 @@ where T: DeserializeOwned + Serialize + PartialEq + std::fmt::Debug
     let buf = toml::to_string(&src).unwrap();
     let dst: T = toml::from_str(&buf).unwrap();
     assert_eq!(src, dst);
-}
+}