Feed backs, please

model.rs

use serde::{Serialize};

use mongodb::bson::{
  to_bson,
  Bson,
};

pub trait Model : Serialize {
  fn to_bson(&self) -> Bson {
    to_bson(self).unwrap()
  }
}

provider.rs

use async_trait::async_trait;

use mongodb::{
  error::Error,
  Collection,
  results::{
    InsertOneResult
  }
};

use crate::db::Connection;
use crate::models::Model;

#[async_trait]
pub trait Provider<T:Model + std::marker::Sync + std::marker::Send> {

  fn init(conn:&Connection) -> Self;
  fn get_collection(&self) -> &Collection;

  async fn save<'a>(&self, model: &'a T) -> Result<InsertOneResult, Error> {
    self.get_collection().insert_one(
      model.to_bson().as_document().unwrap().clone(),
      None
    ).await
  }
}

user_model.rs

use serde::{Deserialize, Serialize};
use mongodb::bson::{
  oid::ObjectId
};

use super::model::Model;

#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct User {
  #[serde(rename="_id", skip_serializing_if="Option::is_none")]
  pub id:Option<ObjectId>,
  pub login:String,
  pub email:String,
  pub avatar:String,
  pub token:String,
}

impl Model for User {}

user_provider.rs

use mongodb::{
  Collection,
};

use super::provider::Provider;

use crate::db::Connection;
use crate::models::User;
pub struct UserProvider {
  collection:Collection
}

impl Provider<User> for UserProvider {

  fn init(conn:&Connection) -> Self {
    Self {
      collection: conn.database.collection("users")
    }
  }

  fn get_collection(&self) -> &Collection {
    &self.collection
  }
}