-
-
-
- ⚙ Contacts
-
-
- > {
- vec![Box::new(m20220101_000001_create_table::Migration)]
- }
-}
diff --git a/migration/src/m20220101_000001_create_table.rs b/migration/src/m20220101_000001_create_table.rs
deleted file mode 100644
index caa8276..0000000
--- a/migration/src/m20220101_000001_create_table.rs
+++ /dev/null
@@ -1,98 +0,0 @@
-use sea_orm_migration::prelude::*;
-
-#[derive(Iden)]
-enum Users {
- Table,
- Id,
- Username,
- CreatedAt,
-}
-
-#[derive(Iden)]
-enum Messages {
- Table,
- Id,
- FromUser,
- ToUser,
- Content,
- CreatedAt,
-}
-
-#[derive(DeriveMigrationName)]
-pub struct Migration;
-
-#[async_trait::async_trait]
-impl MigrationTrait for Migration {
- async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
- manager
- .create_table(
- Table::create()
- .table(Users::Table)
- .if_not_exists()
- .col(
- ColumnDef::new(Users::Id)
- .integer()
- .not_null()
- .auto_increment()
- .primary_key(),
- )
- .col(
- ColumnDef::new(Users::Username)
- .string()
- .not_null()
- .unique_key(),
- )
- .col(
- ColumnDef::new(Users::CreatedAt)
- .date_time()
- .not_null()
- .extra("DEFAULT CURRENT_TIMESTAMP".to_string()),
- )
- .to_owned(),
- )
- .await?;
-
- manager
- .create_table(
- Table::create()
- .table(Messages::Table)
- .if_not_exists()
- .col(ColumnDef::new(Messages::Id).uuid().not_null().primary_key())
- .col(ColumnDef::new(Messages::FromUser).string().not_null())
- .col(ColumnDef::new(Messages::ToUser).string().not_null())
- .col(ColumnDef::new(Messages::Content).text().not_null())
- .col(
- ColumnDef::new(Messages::CreatedAt)
- .date_time()
- .not_null()
- .extra("DEFAULT CURRENT_TIMESTAMP".to_string()),
- )
- .foreign_key(
- ForeignKey::create()
- .name("fk-messages-from_user")
- .from(Messages::Table, Messages::FromUser)
- .to(Users::Table, Users::Username),
- )
- .foreign_key(
- ForeignKey::create()
- .name("fk-messages-to_user")
- .from(Messages::Table, Messages::ToUser)
- .to(Users::Table, Users::Username),
- )
- .to_owned(),
- )
- .await?;
-
- Ok(())
- }
-
- async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
- manager
- .drop_table(Table::drop().table(Messages::Table).to_owned())
- .await?;
- manager
- .drop_table(Table::drop().table(Users::Table).to_owned())
- .await?;
- Ok(())
- }
-}
diff --git a/migration/src/main.rs b/migration/src/main.rs
deleted file mode 100644
index f054dea..0000000
--- a/migration/src/main.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-use sea_orm_migration::prelude::*;
-
-#[tokio::main]
-async fn main() {
- cli::run_cli(migration::Migrator).await;
-}
diff --git a/src/entities/messages.rs b/src/entities/messages.rs
deleted file mode 100644
index 6b599b7..0000000
--- a/src/entities/messages.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-use sea_orm::entity::prelude::*;
-use serde::{Deserialize, Serialize};
-
-#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Serialize, Deserialize)]
-#[sea_orm(table_name = "messages")]
-pub struct Model {
- #[sea_orm(primary_key, auto_increment = false)]
- pub id: Uuid,
- pub from_user: String,
- pub to_user: String,
- pub content: String,
- pub created_at: DateTime,
-}
-
-#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
-pub enum Relation {
- #[sea_orm(
- belongs_to = "super::users::Entity",
- from = "Column::FromUser",
- to = "super::users::Column::Username"
- )]
- FromUser,
- #[sea_orm(
- belongs_to = "super::users::Entity",
- from = "Column::ToUser",
- to = "super::users::Column::Username"
- )]
- ToUser,
-}
-
-impl Related for Entity {
- fn to() -> RelationDef {
- Relation::FromUser.def() // Or ToUser, depending on what you want as the 'default' relationship
- }
-}
-
-impl ActiveModelBehavior for ActiveModel {}
diff --git a/src/entities/mod.rs b/src/entities/mod.rs
deleted file mode 100644
index 5a8b2b3..0000000
--- a/src/entities/mod.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-pub mod messages;
-pub mod users;
-
-pub mod prelude {
- pub use super::messages::Entity as Messages;
- pub use super::users::Entity as Users;
-}
diff --git a/src/entities/users.rs b/src/entities/users.rs
deleted file mode 100644
index 7bcd081..0000000
--- a/src/entities/users.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-use sea_orm::entity::prelude::*;
-use serde::{Deserialize, Serialize};
-
-#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Serialize, Deserialize)]
-#[sea_orm(table_name = "users")]
-pub struct Model {
- #[sea_orm(primary_key)]
- pub id: i32,
- #[sea_orm(unique)]
- pub username: String,
- pub created_at: DateTime,
-}
-
-#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
-pub enum Relation {
- #[sea_orm(has_many = "super::messages::Entity")]
- Messages,
-}
-
-impl Related for Entity {
- fn to() -> RelationDef {
- Relation::Messages.def()
- }
-}
-
-impl ActiveModelBehavior for ActiveModel {}
diff --git a/src/main.rs b/src/main.rs
index 9754e17..69fb1d7 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,445 +1,211 @@
use axum::{
- Router,
extract::{
- Query, State,
ws::{Message, WebSocket, WebSocketUpgrade},
+ Query, State,
},
- http::{HeaderMap, StatusCode},
- response::{Html, IntoResponse},
+ http::StatusCode,
+ response::{Html, IntoResponse, Redirect},
routing::get,
+ Router,
};
use dotenvy::dotenv;
use futures::{sink::SinkExt, stream::StreamExt};
-use jsonwebtoken::{Algorithm, DecodingKey, Validation, decode, decode_header};
-use serde::{Deserialize, Serialize};
-use std::{collections::HashMap, sync::Arc};
-use tokio::sync::{RwLock, mpsc};
-
-use migration::{Migrator, MigratorTrait};
-use sea_orm::{
- ActiveModelTrait, ActiveValue, ColumnTrait, Condition, Database, DatabaseConnection,
- EntityTrait, QueryFilter, QueryOrder,
+use oauth2::{
+ basic::BasicClient,AuthUrl, ClientId, ClientSecret, RedirectUrl, TokenResponse,
+ TokenUrl,
};
+use std::sync::Arc;
+use tokio::sync::broadcast;
+use tower_sessions::{cookie::SameSite, Expiry, MemoryStore, Session, SessionManagerLayer};
-mod entities;
mod user;
-use entities::{messages, prelude::*, users};
use user::User;
-// WebSocket message types for client-server communication
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(tag = "type")]
-enum WsMessage {
- #[serde(rename = "user_list")]
- UserList {
- users: Vec,
- online: Vec,
- },
- #[serde(rename = "private_message")]
- PrivateMessage {
- from: String,
- to: String,
- content: String,
- },
- #[serde(rename = "identity")]
- Identity { username: String },
- #[serde(rename = "user_joined")]
- UserJoined { username: String },
- #[serde(rename = "system")]
- System { content: String },
-}
-
-// Per-user connection channel
-type UserTx = mpsc::UnboundedSender;
-
-// Shared state for tracking online users and their connections
-struct ChatState {
- // Map of username -> sender channel
- connections: RwLock>,
-}
-
-impl ChatState {
- fn new() -> Self {
- Self {
- connections: RwLock::new(HashMap::new()),
- }
- }
-
- async fn add_user(&self, username: String, tx: UserTx) {
- let mut conns = self.connections.write().await;
- conns.insert(username, tx);
- }
-
- async fn remove_user(&self, username: &str) {
- let mut conns = self.connections.write().await;
- conns.remove(username);
- }
-
- async fn get_online_users(&self) -> Vec {
- let conns = self.connections.read().await;
- conns.keys().cloned().collect()
- }
-
- async fn send_to_user(&self, username: &str, message: &str) -> bool {
- let conns = self.connections.read().await;
- if let Some(tx) = conns.get(username) {
- tx.send(message.to_string()).is_ok()
- } else {
- false
- }
- }
-
- async fn broadcast_except(&self, message: &str, exclude: &str) {
- let conns = self.connections.read().await;
- for (username, tx) in conns.iter() {
- if username != exclude {
- let _ = tx.send(message.to_string());
- }
- }
- }
-}
-
-// Application state
+// Define application state
struct AppState {
- chat: ChatState,
- jwks: RwLock>,
- db: DatabaseConnection,
+ tx: broadcast::Sender,
+ oauth_client: BasicClient,
}
+const AFTER_LOGIN_URL: &str = "/";
+
#[tokio::main]
async fn main() {
dotenv().ok();
- let database_url = dotenvy::var("DATABASE_URL").expect("DATABASE_URL must be set");
- let db = Database::connect(database_url)
- .await
- .expect("Failed to connect to database");
+ // Create a broadcast channel
+ let (tx, _rx) = broadcast::channel(100);
- // Run migrations
- Migrator::up(&db, None)
- .await
- .expect("Failed to run migrations");
+ // OAuth configuration
+ let client_id = dotenvy::var("CLIENT_ID").unwrap();
+ let client_secret = dotenvy::var("CLIENT_SECRET").unwrap();
+ let port = dotenvy::var("PORT").unwrap_or_else(|_| "3001".to_string());
+ let host = dotenvy::var("HOST").unwrap_or_else(|_| "http://localhost:".to_string() + &port);
+ // NOTE: In production, do not hardcode localhost
+ let auth_url = AuthUrl::new("https://idm.flegr.me/application/o/authorize/".to_string())
+ .expect("Invalid authorization endpoint URL");
+ let token_url = TokenUrl::new("https://idm.flegr.me/application/o/token/".to_string())
+ .expect("Invalid token endpoint URL");
- let chat = ChatState::new();
- let jwks = RwLock::new(HashMap::new());
+ let client = BasicClient::new(
+ ClientId::new(client_id),
+ Some(ClientSecret::new(client_secret)),
+ auth_url,
+ Some(token_url),
+ )
+ .set_redirect_uri(
+ RedirectUrl::new(host + "/auth/callback")
+ .expect("Invalid redirect URL"),
+ );
- let app_state = Arc::new(AppState { chat, jwks, db });
+ let app_state = Arc::new(AppState {
+ tx,
+ oauth_client: client,
+ });
- // Initial JWKS fetch
- if let Err(e) = fetch_jwks(&app_state).await {
- eprintln!("Warning: Failed to fetch initial JWKS: {}", e);
- }
+ // Session configuration
+ let session_store = MemoryStore::default();
+ let session_layer = SessionManagerLayer::new(session_store)
+ .with_secure(false) // For localhost; set to true in production with HTTPS
+ .with_same_site(SameSite::Lax) // Ensure we can receive cookies from OAuth redirect
+ .with_expiry(Expiry::OnInactivity(time::Duration::minutes(30)));
// Build application with routes
let app = Router::new()
.route("/", get(index))
- .route("/api/history", get(get_history))
+ .route("/login", get(login))
+ .route("/logout", get(logout))
+ .route("/auth/callback", get(auth_callback))
.route("/ws", get(websocket_handler))
+ .layer(session_layer)
.with_state(app_state);
// Run the app
let port = dotenvy::var("PORT").unwrap_or_else(|_| "3001".to_string());
- let listener = tokio::net::TcpListener::bind("0.0.0.0:".to_string() + &port)
- .await
- .unwrap();
+ let listener = tokio::net::TcpListener::bind("0.0.0.0:".to_string() + &port).await.unwrap();
println!("Chat server listening on http://0.0.0.0:{}", port);
axum::serve(listener, app).await.unwrap();
}
-async fn fetch_jwks(state: &AppState) -> Result<(), Box> {
- let resp: JwkSet = reqwest::get("https://idm.flegr.me/application/o/chat/jwks/")
- .await?
- .json()
- .await?;
-
- let mut keys = state.jwks.write().await;
- for jwk in resp.keys {
- if let (Some(kid), Some(n), Some(e)) = (jwk.kid, jwk.n, jwk.e) {
- keys.insert(kid, (n, e));
- }
- }
- println!("Fetched {} public keys from Authentik", keys.len());
- Ok(())
-}
-
-#[derive(Deserialize)]
-struct JwkSet {
- keys: Vec,
-}
-
-#[derive(Deserialize)]
-struct Jwk {
- kid: Option,
- n: Option,
- e: Option,
-}
-
// Handlers
-async fn index() -> impl IntoResponse {
- Html(include_str!("../index.html"))
-}
-
-#[derive(Deserialize)]
-struct WsParams {
- token: String,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-struct Claims {
- preferred_username: String,
- // Add other fields as needed
-}
-
-async fn verify_token(token: &str, state: &AppState) -> Result {
- let header = match decode_header(token) {
- Ok(h) => h,
- Err(_) => return Err(StatusCode::BAD_REQUEST),
- };
-
- let kid = match header.kid {
- Some(k) => k,
- None => return Err(StatusCode::UNAUTHORIZED),
- };
-
- let components = {
- let jwks = state.jwks.read().await;
- if let Some(c) = jwks.get(&kid).cloned() {
- c
- } else {
- // Key not found, might need to refresh JWKS
- drop(jwks);
- if let Err(e) = fetch_jwks(state).await {
- eprintln!("Failed to refresh JWKS: {}", e);
- return Err(StatusCode::UNAUTHORIZED);
- }
- let jwks = state.jwks.read().await;
- match jwks.get(&kid).cloned() {
- Some(c) => c,
- None => return Err(StatusCode::UNAUTHORIZED),
- }
- }
- };
-
- let key = match DecodingKey::from_rsa_components(&components.0, &components.1) {
- Ok(k) => k,
- Err(_) => return Err(StatusCode::INTERNAL_SERVER_ERROR),
- };
-
- let mut validation = Validation::new(Algorithm::RS256);
- validation.set_audience(&["xLL8a23JBnBvEarjQUY6Jgd4zLnnqIi2y3oB6laM"]);
- validation.set_issuer(&["https://idm.flegr.me/application/o/chat/"]);
-
- match decode::(token, &key, &validation) {
- Ok(c) => Ok(c.claims),
- Err(e) => {
- eprintln!("Token validation failed: {}", e);
- Err(StatusCode::UNAUTHORIZED)
- }
+async fn index(session: Session) -> impl IntoResponse {
+ if let Some(_user) = session.get::("user").await.unwrap() {
+ return Html(include_str!("../index.html")).into_response();
}
+ Redirect::to("/login").into_response()
+}
+
+async fn login(State(state): State>) -> impl IntoResponse {
+ let (auth_url, _csrf_token) = state
+ .oauth_client
+ .authorize_url(oauth2::CsrfToken::new_random)
+ .url();
+
+ Redirect::to(auth_url.as_str())
+}
+
+async fn logout(session: Session) -> impl IntoResponse {
+ session.delete().await.unwrap();
+ Redirect::to("/login")
+}
+
+#[derive(serde::Deserialize)]
+struct AuthRequest {
+ code: String,
+ state: String,
+}
+
+async fn auth_callback(
+ Query(query): Query,
+ State(state): State>,
+ session: Session,
+) -> impl IntoResponse {
+ let token = match state
+ .oauth_client
+ .exchange_code(oauth2::AuthorizationCode::new(query.code))
+ .request_async(oauth2::reqwest::async_http_client)
+ .await
+ {
+ Ok(t) => t,
+ Err(e) => {
+ return (
+ StatusCode::BAD_REQUEST,
+ format!("Failed to exchange authorization code: {}", e),
+ )
+ .into_response();
+ }
+ };
+
+ let client = reqwest::Client::new();
+ let user_info_resp = client
+ .get("https://idm.flegr.me/application/o/userinfo/")
+ .header("User-Agent", "axum-chat-app")
+ .bearer_auth(token.access_token().secret())
+ .send()
+ .await;
+
+ let user_data: User = match user_info_resp {
+ Ok(resp) => match resp.json().await {
+ Ok(u) => u,
+ Err(e) => return (
+ StatusCode::INTERNAL_SERVER_ERROR,
+ format!("Failed to parse user info: {}", e)
+ ).into_response()
+ },
+ Err(e) => return (
+ StatusCode::INTERNAL_SERVER_ERROR,
+ format!("Failed to fetch user info: {}", e)
+ ).into_response()
+ };
+
+ session.insert("user", user_data).await.unwrap();
+
+ Redirect::to(AFTER_LOGIN_URL).into_response()
}
async fn websocket_handler(
ws: WebSocketUpgrade,
- Query(params): Query,
State(state): State>,
+ session: Session,
) -> impl IntoResponse {
- let claims = match verify_token(¶ms.token, &state).await {
- Ok(c) => c,
- Err(status) => return status.into_response(),
- };
-
- let user = User {
- login: claims.preferred_username,
- avatar_url: String::new(),
- };
-
- // Ensure user exists in DB
- let user_active_model = users::ActiveModel {
- username: ActiveValue::Set(user.login.clone()),
- ..Default::default()
- };
- let _ = Users::insert(user_active_model)
- .on_conflict(
- sea_orm::sea_query::OnConflict::column(users::Column::Username)
- .do_nothing()
- .to_owned(),
- )
- .exec(&state.db)
- .await;
-
- let state_clone = state.clone();
- ws.on_upgrade(move |socket| handle_websocket(socket, state_clone, user))
-}
-
-#[derive(Deserialize)]
-struct HistoryParams {
- to: String,
-}
-
-async fn get_history(
- headers: HeaderMap,
- Query(params): Query,
- State(state): State>,
-) -> impl IntoResponse {
- let auth_header = match headers.get(axum::http::header::AUTHORIZATION) {
- Some(h) => h.to_str().unwrap_or(""),
- None => return StatusCode::UNAUTHORIZED.into_response(),
- };
-
- if !auth_header.starts_with("Bearer ") {
- return StatusCode::UNAUTHORIZED.into_response();
- }
-
- let token = &auth_header[7..];
- let claims = match verify_token(token, &state).await {
- Ok(c) => c,
- Err(status) => return status.into_response(),
- };
-
- let current_user = claims.preferred_username;
-
- let messages = Messages::find()
- .filter(
- Condition::any()
- .add(
- Condition::all()
- .add(messages::Column::FromUser.eq(current_user.clone()))
- .add(messages::Column::ToUser.eq(params.to.clone())),
- )
- .add(
- Condition::all()
- .add(messages::Column::FromUser.eq(params.to))
- .add(messages::Column::ToUser.eq(current_user)),
- ),
- )
- .order_by_asc(messages::Column::CreatedAt)
- .all(&state.db)
- .await;
-
- match messages {
- Ok(msgs) => axum::Json(msgs).into_response(),
- Err(e) => {
- eprintln!("Failed to fetch history: {}", e);
- StatusCode::INTERNAL_SERVER_ERROR.into_response()
- }
+ if let Some(user) = session.get::("user").await.unwrap() {
+ return ws.on_upgrade(move |socket| websocket(socket, state, user));
}
+ StatusCode::UNAUTHORIZED.into_response()
}
-// WebSocket connection handler
-async fn handle_websocket(stream: WebSocket, state: Arc, user: User) {
- let (mut ws_sender, mut ws_receiver) = stream.split();
- let username = user.login.clone();
+// WebSocket handler
+async fn websocket(stream: WebSocket, state: Arc, user: User) {
+ let (mut sender, mut receiver) = stream.split();
+ let mut rx = state.tx.subscribe();
- // Create channel for this user
- let (tx, mut rx) = mpsc::unbounded_channel::();
+ // Send welcome message
+ let msg = format!("System: Welcome, {}!", user.login);
+ let _ = sender.send(Message::Text(msg.into())).await;
- // Add user to connections
- state.chat.add_user(username.clone(), tx).await;
- println!("User connected: {}", username);
-
- // Send identity
- let identity_msg = serde_json::to_string(&WsMessage::Identity {
- username: username.clone(),
- })
- .unwrap();
- let _ = ws_sender.send(Message::Text(identity_msg.into())).await;
-
- // Send global user list and online status to the newly connected user
- let (db_users, online_users) = match Users::find().all(&state.db).await {
- Ok(all_users) => {
- let db_list = all_users
- .into_iter()
- .map(|u| u.username)
- .filter(|u| u != &username)
- .collect::>();
- let online_list = state.chat.get_online_users().await;
- (db_list, online_list)
- }
- Err(e) => {
- eprintln!("Failed to fetch users from DB: {}", e);
- (Vec::new(), Vec::new())
- }
- };
- println!(
- "Sending global user list to {}: DB Count={}, Online Count={}",
- username,
- db_users.len(),
- online_users.len()
- );
- let user_list_msg = serde_json::to_string(&WsMessage::UserList {
- users: db_users,
- online: online_users,
- })
- .unwrap();
- let _ = ws_sender.send(Message::Text(user_list_msg.into())).await;
-
- // Task to forward messages from channel to WebSocket
- let send_task = tokio::spawn(async move {
- while let Some(msg) = rx.recv().await {
- if ws_sender.send(Message::Text(msg.into())).await.is_err() {
+ // Send task
+ let mut send_task = tokio::spawn(async move {
+ while let Ok(msg) = rx.recv().await {
+ if sender.send(Message::Text(msg.into())).await.is_err() {
break;
}
}
});
- // Broadcast user joined to everyone else (after send_task is spawned so others receive it)
- let join_msg = serde_json::to_string(&WsMessage::UserJoined {
- username: username.clone(),
- })
- .unwrap();
- state.chat.broadcast_except(&join_msg, &username).await;
-
- // Task to receive messages from WebSocket and route them
- let state_clone = state.clone();
- let username_clone = username.clone();
- let recv_task = tokio::spawn(async move {
- while let Some(Ok(Message::Text(text))) = ws_receiver.next().await {
- // Parse incoming message
- if let Ok(msg) = serde_json::from_str::(&text) {
- // Persist to DB
- let new_message = messages::ActiveModel {
- id: ActiveValue::Set(uuid::Uuid::new_v4()),
- from_user: ActiveValue::Set(username_clone.clone()),
- to_user: ActiveValue::Set(msg.to.clone()),
- content: ActiveValue::Set(msg.content.clone()),
- ..Default::default()
- };
- let _ = new_message.insert(&state_clone.db).await;
-
- // Create private message
- let private_msg = serde_json::to_string(&WsMessage::PrivateMessage {
- from: username_clone.clone(),
- to: msg.to.clone(),
- content: msg.content.clone(),
- })
- .unwrap();
-
- // Send to recipient
- state_clone.chat.send_to_user(&msg.to, &private_msg).await;
-
- // Also send back to sender (for their own chat view)
- state_clone
- .chat
- .send_to_user(&username_clone, &private_msg)
- .await;
- }
+ // Receive task
+ let tx = state.tx.clone();
+ let username = user.login.clone();
+ let mut recv_task = tokio::spawn(async move {
+ while let Some(Ok(Message::Text(text))) = receiver.next().await {
+ // Prepend username
+ let msg = format!("{}: {}", username, text);
+ let _ = tx.send(msg);
}
});
- // Wait for either task to complete
tokio::select! {
- _ = send_task => {},
- _ = recv_task => {},
- }
-
- // User disconnected - clean up
- state.chat.remove_user(&username).await;
-}
-
-// Message structure from client
-#[derive(Debug, Deserialize)]
-struct ClientMessage {
- to: String,
- content: String,
+ _ = (&mut send_task) => recv_task.abort(),
+ _ = (&mut recv_task) => send_task.abort(),
+ };
}
Select a contact to start chatting
- Click on a contact to begin transmission...
-
-
-
-
-
+
+
+
diff --git a/migration/Cargo.toml b/migration/Cargo.toml
deleted file mode 100644
index 000eee9..0000000
--- a/migration/Cargo.toml
+++ /dev/null
@@ -1,13 +0,0 @@
-[package]
-name = "migration"
-version = "0.1.0"
-edition = "2024"
-
-[lib]
-name = "migration"
-path = "src/lib.rs"
-
-[dependencies]
-async-trait = "0.1"
-sea-orm-migration = { version = "1.1.0", features = ["runtime-tokio-rustls", "sqlx-postgres"] }
-tokio = { version = "1", features = ["full"] }
diff --git a/migration/src/lib.rs b/migration/src/lib.rs
deleted file mode 100644
index 2c605af..0000000
--- a/migration/src/lib.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-pub use sea_orm_migration::prelude::*;
-
-mod m20220101_000001_create_table;
-
-pub struct Migrator;
-
-#[async_trait::async_trait]
-impl MigratorTrait for Migrator {
- fn migrations() -> Vec
+
+