Clippy fixes

.envrc

@@ -0,0 +1,3 @@
+source_url "https://raw.githubusercontent.com/cachix/devenv/82c0147677e510b247d8b9165c54f73d32dfd899/direnvrc" "sha256-7u4iDd1nZpxL4tCzmPG0dQgC5V+/44Ba+tHkPob1v2k="
+
+use devenv

.gitignore

@@ -0,0 +1,12 @@
+# Devenv
+.devenv*
+devenv.local.nix
+
+# direnv
+.direnv
+
+# pre-commit
+.pre-commit-config.yaml
+
+# Other
+.env

client/.gitignore

@@ -0,0 +1,24 @@
+# Nuxt dev/build outputs
+.output
+.data
+.nuxt
+.nitro
+.cache
+dist
+
+# Node dependencies
+node_modules
+
+# Logs
+logs
+*.log
+
+# Misc
+.DS_Store
+.fleet
+.idea
+
+# Local env files
+.env
+.env.*
+!.env.example

client/README.md

@@ -0,0 +1,75 @@
+# Nuxt Minimal Starter
+
+Look at the [Nuxt documentation](https://nuxt.com/docs/getting-started/introduction) to learn more.
+
+## Setup
+
+Make sure to install dependencies:
+
+```bash
+# npm
+npm install
+
+# pnpm
+pnpm install
+
+# yarn
+yarn install
+
+# bun
+bun install
+```
+
+## Development Server
+
+Start the development server on `http://localhost:3000`:
+
+```bash
+# npm
+npm run dev
+
+# pnpm
+pnpm dev
+
+# yarn
+yarn dev
+
+# bun
+bun run dev
+```
+
+## Production
+
+Build the application for production:
+
+```bash
+# npm
+npm run build
+
+# pnpm
+pnpm build
+
+# yarn
+yarn build
+
+# bun
+bun run build
+```
+
+Locally preview production build:
+
+```bash
+# npm
+npm run preview
+
+# pnpm
+pnpm preview
+
+# yarn
+yarn preview
+
+# bun
+bun run preview
+```
+
+Check out the [deployment documentation](https://nuxt.com/docs/getting-started/deployment) for more information.

client/app.vue

@@ -0,0 +1,6 @@
+<template>
+  <div>
+    <NuxtRouteAnnouncer />
+    <NuxtWelcome />
+  </div>
+</template>

client/nuxt.config.ts

@@ -0,0 +1,5 @@
+// https://nuxt.com/docs/api/configuration/nuxt-config
+export default defineNuxtConfig({
+  compatibilityDate: '2024-11-01',
+  devtools: { enabled: true }
+})

client/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "nuxt-app",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "build": "nuxt build",
+    "dev": "nuxt dev",
+    "generate": "nuxt generate",
+    "preview": "nuxt preview",
+    "postinstall": "nuxt prepare"
+  },
+  "dependencies": {
+    "nuxt": "^3.15.1",
+    "vue": "latest",
+    "vue-router": "latest"
+  },
+  "packageManager": "pnpm@9.15.4+sha512.b2dc20e2fc72b3e18848459b37359a32064663e5627a51e4c74b2c29dd8e8e0491483c3abb40789cfd578bf362fb6ba8261b05f0387d76792ed6e23ea3b1b6a0"
+}

client/public/robots.txt

@@ -0,0 +1 @@
+

client/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../.nuxt/tsconfig.server.json"
+}

client/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  // https://nuxt.com/docs/guide/concepts/typescript
+  "extends": "./.nuxt/tsconfig.json"
+}

devenv.lock

@@ -0,0 +1,103 @@
+{
+  "nodes": {
+    "devenv": {
+      "locked": {
+        "dir": "src/modules",
+        "lastModified": 1736426010,
+        "owner": "cachix",
+        "repo": "devenv",
+        "rev": "1c384bc4be3ee571511fbbc6fdc94fe47d60f6cf",
+        "type": "github"
+      },
+      "original": {
+        "dir": "src/modules",
+        "owner": "cachix",
+        "repo": "devenv",
+        "type": "github"
+      }
+    },
+    "flake-compat": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1733328505,
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "rev": "ff81ac966bb2cae68946d5ed5fc4994f96d0ffec",
+        "type": "github"
+      },
+      "original": {
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "type": "github"
+      }
+    },
+    "git-hooks": {
+      "inputs": {
+        "flake-compat": "flake-compat",
+        "gitignore": "gitignore",
+        "nixpkgs": [
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1737465171,
+        "owner": "cachix",
+        "repo": "git-hooks.nix",
+        "rev": "9364dc02281ce2d37a1f55b6e51f7c0f65a75f17",
+        "type": "github"
+      },
+      "original": {
+        "owner": "cachix",
+        "repo": "git-hooks.nix",
+        "type": "github"
+      }
+    },
+    "gitignore": {
+      "inputs": {
+        "nixpkgs": [
+          "git-hooks",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1709087332,
+        "owner": "hercules-ci",
+        "repo": "gitignore.nix",
+        "rev": "637db329424fd7e46cf4185293b9cc8c88c95394",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hercules-ci",
+        "repo": "gitignore.nix",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1733477122,
+        "owner": "cachix",
+        "repo": "devenv-nixpkgs",
+        "rev": "7bd9e84d0452f6d2e63b6e6da29fe73fac951857",
+        "type": "github"
+      },
+      "original": {
+        "owner": "cachix",
+        "ref": "rolling",
+        "repo": "devenv-nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "devenv": "devenv",
+        "git-hooks": "git-hooks",
+        "nixpkgs": "nixpkgs",
+        "pre-commit-hooks": [
+          "git-hooks"
+        ]
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

devenv.nix

@@ -0,0 +1,26 @@
+{ pkgs, ... }:
+
+{
+  packages = with pkgs; [
+    openssl
+  ];
+
+  languages.rust.enable = true;
+
+  languages.javascript = {
+    enable = true;
+    pnpm.enable = true;
+  };
+
+  services.postgres = {
+    enable = true;
+    listen_addresses = "127.0.0.1";
+    initialDatabases = [
+      {
+        name = "wrbapp";
+        pass = "password";
+        user = "wrbapp";  
+      }
+    ];
+  };
+}

devenv.yaml

@@ -0,0 +1,15 @@
+# yaml-language-server: $schema=https://devenv.sh/devenv.schema.json
+inputs:
+  nixpkgs:
+    url: github:cachix/devenv-nixpkgs/rolling
+
+# If you're using non-OSS software, you can set allowUnfree to true.
+# allowUnfree: true
+
+# If you're willing to use a package that's vulnerable
+# permittedInsecurePackages:
+#  - "openssl-1.1.1w"
+
+# If you have more than one devenv you can merge them
+#imports:
+# - ./backend

server/.gitignore

@@ -0,0 +1,2 @@
+target/
+.env

server/Cargo.toml

@@ -0,0 +1,33 @@
+[package]
+name = "wrbapp_server"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+# Primary crates
+axum = { version = "0.8", features = [ "macros", "json" ] }
+axum-extra = { version = "0.10.0", features = [ "typed-header", "cookie" ] }
+tokio = { version = "1.43", features = [ "rt-multi-thread", "macros" ] }
+sqlx = { version = "0.8", features = [ "runtime-tokio", "postgres", "uuid", "chrono" ] }
+
+# Secondary crates
+csv = { version = "1.3" }
+serde = "1.0"
+dotenvy = "0.15.7"
+validator = { version = "0.19.0", features = [ "derive" ] }
+argon2 = "0.5"
+bitflags = { version = "2.8", features = [ "serde" ] }
+clap = { version = "4.5.31", features = ["derive"] }
+
+
+# Tertiary crates
+tracing = "0.1"
+tracing-subscriber = "0.3"
+chrono = { version = "0.4", features = ["serde"] }
+uuid = { version = "1.12", features = ["v4", "fast-rng", "serde"] }
+serde_json = "1.0.137"
+rand = "0.9"
+rand_chacha = "0.9"
+thiserror = { version = "2.0" }
+itertools = "0.14"
+

server/build.rs

@@ -0,0 +1,5 @@
+// generated by `sqlx migrate build-script`
+fn main() {
+    // trigger recompilation when a new migration is added
+    println!("cargo:rerun-if-changed=migrations");
+}

server/migrations/001_create_members.sql

@@ -0,0 +1,10 @@
+CREATE TABLE IF NOT EXISTS "members" (
+  member_id           varchar(7)  NOT NULL PRIMARY KEY,
+  first_name          text        NOT NULL,
+  full_name           text        NOT NULL,
+  registration_token  text        NOT NULL UNIQUE,
+  diploma             text,
+  groups              bigint      NOT NULL,
+  roles               bigint      NOT NULL
+);
+

server/migrations/002_create_users.sql

@@ -0,0 +1,13 @@
+CREATE TABLE IF NOT EXISTS "users" (
+  user_id   uuid     NOT NULL PRIMARY KEY,
+  email     text     NOT NULL UNIQUE,
+  password  text     NOT NULL,
+  admin     boolean  NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS users_members (
+  user_id   uuid        NOT NULL REFERENCES users (user_id) ON UPDATE cascade ON DELETE cascade,
+  member_id varchar(7)  NOT NULL REFERENCES members (member_id) ON UPDATE cascade ON DELETE cascade,
+
+  CONSTRAINT users_members_pkey PRIMARY KEY (user_id, member_id)
+);

server/migrations/003_create_sessions.sql

@@ -0,0 +1,7 @@
+CREATE TABLE IF NOT EXISTS "sessions" (
+    session_id  uuid      NOT NULL PRIMARY KEY,
+    user_id     uuid      NOT NULL REFERENCES users (user_id) ON UPDATE cascade ON DELETE cascade,
+    token       text      NOT NULL UNIQUE,
+    expires_at  timestamptz  NOT NULL, 
+    created_at  timestamptz  NOT NULL
+);

server/migrations/004_unique_users_members.sql

@@ -0,0 +1,2 @@
+ALTER TABLE users_members
+    ADD UNIQUE (user_id, member_id);

server/migrations/005_create_news.sql

@@ -0,0 +1,20 @@
+CREATE TYPE message_status AS ENUM ('pending', 'sent', 'canceled');
+
+CREATE TABLE IF NOT EXISTS messages (
+    message_id    uuid            NOT NULL PRIMARY KEY,
+    created_at    timestamptz     NOT NULL,
+    scheduled_at  timestamptz,
+    status        message_status  NOT NULL,
+    title         text            NOT NULL,
+    content       text            NOT NULL,
+    channel       bigint          NOT NULL,
+    thumbnail_url text
+);
+
+CREATE TABLE IF NOT EXISTS messages_users (
+    message_id  uuid    NOT NULL REFERENCES users (user_id) ON UPDATE cascade ON DELETE cascade,
+    user_id     uuid    NOT NULL REFERENCES users (user_id) ON UPDATE cascade ON DELETE cascade,
+    is_read     boolean NOT NULL,
+
+    CONSTRAINT messages_users_pkey PRIMARY KEY (message_id, user_id)
+);

server/migrations/006_alter_messages.sql

@@ -0,0 +1,3 @@
+ALTER TABLE messages
+    ADD COLUMN member_groups bigint NOT NULL,
+    ADD COLUMN member_roles bigint NOT NULL;

server/migrations/007_alter_messages.sql

@@ -0,0 +1 @@
+ALTER TYPE message_status ADD VALUE 'draft';

server/src/auth.rs

@@ -0,0 +1,85 @@
+use argon2::{
+    password_hash::{rand_core::OsRng, PasswordHasher, SaltString},
+    Argon2, PasswordHash, PasswordVerifier,
+};
+use axum::http::{header, HeaderMap};
+use chrono::Utc;
+pub use error::AuthError;
+use rand::distr::Alphanumeric;
+use rand::prelude::*;
+use rand_chacha::ChaCha20Rng;
+use sqlx::PgPool;
+use tokio::task;
+
+use crate::{database::model::Session, model::User};
+
+mod error;
+
+pub async fn get_user_from_header(pool: &PgPool, headers: &HeaderMap) -> Result<User, AuthError> {
+    let token = get_token_from_headers(headers)?;
+
+    let session = match Session::from_token(pool, &token).await {
+        Ok(s) => s,
+        Err(_) => return Err(AuthError::InvalidToken),
+    };
+
+    if session.expires_at < Utc::now() {
+        return Err(AuthError::InvalidToken);
+    }
+
+    let db_user = match crate::database::model::User::get(pool, session.user_id).await {
+        Ok(u) => u,
+        Err(_) => return Err(AuthError::InvalidToken),
+    };
+
+    Ok(db_user.into())
+}
+
+pub fn get_token_from_headers(headers: &HeaderMap) -> Result<String, AuthError> {
+    let bearer = headers.get(header::AUTHORIZATION);
+    let bearer = bearer
+        .ok_or(AuthError::InvalidToken)?
+        .to_str()
+        .map_err(|_| AuthError::InvalidToken)?;
+
+    match bearer.strip_prefix("Bearer ") {
+        Some(token) => Ok(token.to_string()),
+        None => Err(AuthError::InvalidToken),
+    }
+}
+
+pub async fn generate_password_hash(password: String) -> Result<String, AuthError> {
+    let password_hash: Result<String, argon2::password_hash::Error> =
+        task::spawn_blocking(move || {
+            let salt = SaltString::generate(&mut OsRng);
+
+            let argon2 = Argon2::default();
+
+            let password_hash = argon2
+                .hash_password(password.as_bytes(), &salt)?
+                .to_string();
+
+            Ok(password_hash)
+        })
+        .await
+        .unwrap();
+
+    password_hash.map_err(|e| e.into())
+}
+
+pub async fn verify_password_hash(password: &str, hash: &str) -> Result<(), AuthError> {
+    let parsed_hash = PasswordHash::new(hash)?;
+    Argon2::default()
+        .verify_password(password.as_bytes(), &parsed_hash)
+        .map_err(|_| AuthError::InvalidPassword)?;
+
+    Ok(())
+}
+
+pub fn generate_session_token() -> String {
+    ChaCha20Rng::from_os_rng()
+        .sample_iter(&Alphanumeric)
+        .take(60)
+        .map(char::from)
+        .collect::<String>()
+}

server/src/auth/error.rs

@@ -0,0 +1,32 @@
+use std::fmt::Display;
+
+#[derive(Debug)]
+pub enum AuthError {
+    NoPermssions,
+    InvalidToken,
+    Unexpected,
+    InvalidPassword,
+    Unauthorized,
+    HashingFailed(String),
+}
+
+impl Display for AuthError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::NoPermssions => write!(f, "No permissions"),
+            Self::InvalidToken => write!(f, "Invalid token"),
+            Self::Unexpected => write!(f, "Unexpected error"),
+            Self::InvalidPassword => write!(f, "Password is incorrect"),
+            Self::Unauthorized => write!(f, "Authentication is required"),
+            Self::HashingFailed(msg) => write!(f, "Password hashing failed: {}", msg),
+        }
+    }
+}
+
+impl std::error::Error for AuthError {}
+
+impl From<argon2::password_hash::Error> for AuthError {
+    fn from(value: argon2::password_hash::Error) -> Self {
+        AuthError::HashingFailed(value.to_string())
+    }
+}

server/src/database.rs

@@ -0,0 +1,5 @@
+mod postgres;
+pub use postgres::apply_migrations;
+pub use postgres::connect;
+
+pub mod model;

server/src/database/model.rs

@@ -0,0 +1,10 @@
+pub mod member;
+pub mod message;
+pub mod session;
+pub mod user;
+
+pub use member::Member;
+pub use message::Message;
+pub use session::Session;
+pub use user::User;
+pub use user::UserMember;

server/src/database/model/member.rs

@@ -0,0 +1,117 @@
+use rand::distr::{Alphanumeric, SampleString};
+use sqlx::{PgPool, Postgres, QueryBuilder};
+use validator::Validate;
+
+use crate::model::member::{Groups, Roles};
+
+#[derive(Debug, Validate, sqlx::FromRow)]
+pub struct Member {
+    #[validate(length(equal = 7))]
+    pub member_id: String,
+    pub first_name: String,
+    pub full_name: String,
+    pub registration_token: Option<String>,
+    pub diploma: Option<String>,
+    pub groups: Groups,
+    pub roles: Roles,
+}
+
+impl Member {
+    pub async fn get_many_from_registration_tokens(
+        pool: &PgPool,
+        registration_tokens: Vec<String>,
+    ) -> Result<Vec<Self>, sqlx::Error> {
+        let members = sqlx::query_as!(
+            Member,
+            "SELECT * FROM members WHERE registration_token = ANY($1);",
+            &registration_tokens
+        )
+        .fetch_all(pool)
+        .await?;
+
+        Ok(members)
+    }
+
+    pub async fn get_all(pool: &PgPool) -> Result<Vec<Self>, sqlx::Error> {
+        let members = sqlx::query_as!(Member, "SELECT * FROM members;",)
+            .fetch_all(pool)
+            .await?;
+
+        Ok(members)
+    }
+
+    pub async fn insert_many(
+        transaction: &mut sqlx::Transaction<'_, Postgres>,
+        members: Vec<Self>,
+    ) -> Result<(), sqlx::Error> {
+        if members.is_empty() {
+            return Ok(());
+        }
+
+        let mut query_builder = QueryBuilder::new(
+            "INSERT INTO members(member_id, first_name, full_name, registration_token, diploma, groups, roles) "
+        );
+
+        query_builder.push_values(members.into_iter(), |mut b, member| {
+            let registration_token = Alphanumeric.sample_string(&mut rand::rng(), 16);
+
+            b.push_bind(member.member_id);
+            b.push_bind(member.first_name);
+            b.push_bind(member.full_name);
+            b.push_bind(registration_token);
+            b.push_bind(member.diploma);
+            b.push_bind(member.groups.bits() as i64);
+            b.push_bind(member.roles.bits() as i64);
+        });
+
+        let query = query_builder.build();
+        query.execute(&mut **transaction).await?;
+
+        Ok(())
+    }
+
+    pub async fn update_many(
+        transaction: &mut sqlx::Transaction<'_, Postgres>,
+        members: Vec<Self>,
+    ) -> Result<(), sqlx::Error> {
+        if members.is_empty() {
+            return Ok(());
+        }
+
+        for member in members {
+            sqlx::query!(
+                "
+                    UPDATE ONLY members
+                    SET first_name = $1, full_name = $2, diploma = $3, groups = $4, roles = $5
+                    WHERE member_id = $6
+                ",
+                member.first_name,
+                member.full_name,
+                member.diploma,
+                member.groups.bits() as i64,
+                member.roles.bits() as i64,
+                member.member_id
+            )
+            .execute(&mut **transaction)
+            .await?;
+        }
+
+        Ok(())
+    }
+
+    pub async fn remove_many(
+        transaction: &mut sqlx::Transaction<'_, Postgres>,
+        member_ids: &Vec<String>,
+    ) -> Result<(), sqlx::Error> {
+        sqlx::query!(
+            "
+                DELETE FROM members WHERE member_id = ANY($1)
+            ",
+            member_ids
+        )
+        .execute(&mut **transaction)
+        .await?;
+
+        Ok(())
+    }
+}

server/src/database/model/message.rs

@@ -0,0 +1,108 @@
+use chrono::{DateTime, Utc};
+use sqlx::{PgPool, Postgres};
+
+use crate::model::{
+    member::{Groups, Roles},
+    message::{Channel, MessageStatus},
+};
+
+#[derive(Debug)]
+pub struct Message {
+    pub message_id: uuid::Uuid,
+    pub created_at: DateTime<Utc>,
+    pub scheduled_at: Option<DateTime<Utc>>,
+    pub status: MessageStatus,
+    pub title: String,
+    pub content: String,
+    pub channel: Channel,
+    pub member_groups: Groups,
+    pub member_roles: Roles,
+    pub thumbnail_url: Option<String>,
+}
+
+impl Message {
+    pub async fn insert(
+        &self,
+        transaction: &mut sqlx::Transaction<'_, Postgres>,
+    ) -> Result<(), sqlx::Error> {
+        sqlx::query!(
+            "
+                INSERT INTO messages (
+                    message_id,
+                    created_at, scheduled_at,
+                    status,
+                    title, content,
+                    channel,
+                    member_groups, member_roles,
+                    thumbnail_url
+                ) VALUES (
+                    $1,
+                    $2, $3,
+                    $4,
+                    $5, $6,
+                    $7,
+                    $8, $9,
+                    $10
+                )
+            ",
+            self.message_id,
+            self.created_at,
+            self.scheduled_at,
+            self.status as MessageStatus,
+            self.title,
+            self.content,
+            self.channel.bits() as i64,
+            self.member_groups.bits() as i64,
+            self.member_roles.bits() as i64,
+            self.thumbnail_url,
+        )
+        .execute(&mut **transaction)
+        .await?;
+
+        Ok(())
+    }
+
+    pub async fn get(
+        pool: &PgPool,
+        channel: Channel,
+        member_roles: Roles,
+        member_groups: Groups,
+    ) -> Result<Vec<Self>, sqlx::Error> {
+        let messages = sqlx::query_as!(
+            Self,
+            "
+                SELECT message_id, created_at, scheduled_at, status as \"status:MessageStatus\", title, content, channel, member_groups, member_roles, thumbnail_url FROM messages
+                WHERE status = 'sent'
+                    AND (channel & $1) > 0
+                    AND ((member_roles & $2) > 0 AND (member_groups & $3) > 0);
+            ",
+            channel.bits() as i64,
+            member_roles.bits() as i64,
+            member_groups.bits() as i64,
+        )
+        .fetch_all(pool)
+        .await?;
+
+        Ok(messages)
+    }
+
+    pub async fn update_status(
+        transaction: &mut sqlx::Transaction<'_, Postgres>,
+        message_id: &uuid::Uuid,
+        status: MessageStatus,
+    ) -> Result<(), sqlx::Error> {
+        sqlx::query!(
+            "
+                UPDATE ONLY messages
+                SET status = $1
+                WHERE message_id = $2
+            ",
+            status as MessageStatus,
+            message_id,
+        )
+        .execute(&mut **transaction)
+        .await?;
+
+        Ok(())
+    }
+}

server/src/database/model/session.rs

@@ -0,0 +1,96 @@
+use chrono::{DateTime, Utc};
+use sqlx::{PgPool, Postgres};
+
+#[derive(Debug)]
+pub struct Session {
+    pub session_id: uuid::Uuid,
+    pub user_id: uuid::Uuid,
+    pub token: String,
+    pub expires_at: DateTime<Utc>,
+    pub created_at: DateTime<Utc>,
+}
+
+impl Session {
+    pub async fn insert(
+        &self,
+        transaction: &mut sqlx::Transaction<'_, Postgres>,
+    ) -> Result<(), sqlx::Error> {
+        sqlx::query!(
+            "
+                INSERT INTO sessions (
+                    session_id, user_id, token, expires_at, created_at
+                )
+                VALUES (
+                    $1, $2, $3, $4, $5
+                )
+            ",
+            &self.session_id,
+            &self.user_id,
+            &self.token,
+            &self.expires_at,
+            &self.created_at
+        )
+        .execute(&mut **transaction)
+        .await?;
+
+        Ok(())
+    }
+
+    pub async fn from_token(pool: &PgPool, token: &str) -> Result<Self, sqlx::Error> {
+        let session = sqlx::query_as!(Self, "SELECT * FROM sessions WHERE token = $1;", token)
+            .fetch_one(pool)
+            .await?;
+
+        Ok(session)
+    }
+
+    pub async fn remove_many(
+        session_ids: &[uuid::Uuid],
+        transaction: &mut sqlx::Transaction<'_, Postgres>,
+    ) -> Result<(), sqlx::Error> {
+        let deleted_count = sqlx::query_scalar!(
+            "
+                WITH deleted AS (
+                    DELETE FROM sessions
+                    WHERE session_id = ANY($1)
+                    RETURNING 1
+                )
+                SELECT COUNT(*) FROM deleted
+            ",
+            session_ids
+        )
+        .fetch_one(&mut **transaction)
+        .await?;
+
+        if !deleted_count.is_some_and(|c| c >= 1) {
+            return Err(sqlx::Error::RowNotFound);
+        }
+
+        Ok(())
+    }
+
+    pub async fn remove_many_from_token(
+        transaction: &mut sqlx::Transaction<'_, Postgres>,
+        session_tokens: &[String],
+    ) -> Result<(), sqlx::Error> {
+        let deleted_count = sqlx::query_scalar!(
+            "
+                WITH deleted AS (
+                    DELETE FROM sessions
+                    WHERE token = ANY($1)
+                    RETURNING 1
+                )
+                SELECT COUNT(*) FROM deleted
+            ",
+            session_tokens
+        )
+        .fetch_one(&mut **transaction)
+        .await?;
+
+        if !deleted_count.is_some_and(|c| c >= 1) {
+            return Err(sqlx::Error::RowNotFound);
+        }
+
+        Ok(())
+    }
+}

server/src/database/model/user.rs

@@ -0,0 +1,217 @@
+use sqlx::{PgPool, Postgres};
+
+use crate::model::member::{Groups, Roles};
+
+use super::Member as DbMember;
+
+#[derive(validator::Validate)]
+pub struct User {
+    pub user_id: uuid::Uuid,
+    #[validate(email)]
+    pub email: String,
+    pub password: Option<String>,
+    pub admin: bool,
+}
+
+#[derive(Debug)]
+pub struct UpdateUser {
+    pub email: Option<String>,
+    pub password: Option<String>,
+    pub admin: Option<bool>,
+}
+
+impl User {
+    pub async fn insert(
+        transaction: &mut sqlx::Transaction<'_, Postgres>,
+        email: &str,
+        password: &str,
+    ) -> Result<uuid::Uuid, sqlx::Error> {
+        let user_id = uuid::Uuid::new_v4();
+
+        sqlx::query!(
+            "
+                INSERT INTO users (
+                    user_id, email, password, admin
+                )
+                VALUES (
+                    $1, $2, $3, $4
+                );
+            ",
+            &user_id,
+            email,
+            password,
+            false
+        )
+        .execute(&mut **transaction)
+        .await?;
+
+        Ok(user_id)
+    }
+
+    pub async fn get_from_email(transaction: &PgPool, email: String) -> Result<Self, sqlx::Error> {
+        let user = sqlx::query_as!(Self, "SELECT * FROM users WHERE email = $1", email)
+            .fetch_one(transaction)
+            .await?;
+
+        Ok(user)
+    }
+
+    pub async fn get(transaction: &PgPool, user_id: uuid::Uuid) -> Result<Self, sqlx::Error> {
+        let user = sqlx::query_as!(Self, "SELECT * FROM users WHERE user_id = $1", user_id)
+            .fetch_one(transaction)
+            .await?;
+
+        Ok(user)
+    }
+
+    pub async fn get_password(&self, pool: &PgPool) -> Result<String, sqlx::Error> {
+        let password = sqlx::query_scalar!(
+            "
+                SELECT password FROM users WHERE user_id = $1
+            ",
+            self.user_id,
+        )
+        .fetch_one(pool)
+        .await?;
+
+        Ok(password)
+    }
+
+    pub async fn update(
+        &self,
+        transaction: &mut sqlx::Transaction<'_, Postgres>,
+        update_user: UpdateUser,
+    ) -> Result<(), sqlx::Error> {
+        sqlx::query!(
+            "
+                UPDATE users
+                SET email = coalesce($1, email),
+                    password = coalesce($2, password)
+                WHERE user_id = $3;
+            ",
+            update_user.email,
+            update_user.password,
+            self.user_id
+        )
+        .execute(&mut **transaction)
+        .await?;
+
+        Ok(())
+    }
+}
+
+#[derive(Debug)]
+pub struct UserMember {
+    user_id: uuid::Uuid,
+    member_id: String,
+}
+
+impl UserMember {
+    pub async fn insert_many(
+        transaction: &mut sqlx::Transaction<'_, Postgres>,
+        user_ids: &[uuid::Uuid],
+        member_ids: &[String],
+    ) -> Result<(), sqlx::Error> {
+        sqlx::query!(
+            "
+                INSERT INTO users_members (
+                    user_id, member_id
+                )
+                SELECT * FROM UNNEST($1::uuid[], $2::varchar[])
+            ",
+            &user_ids[..],
+            &member_ids[..]
+        )
+        .execute(&mut **transaction)
+        .await?;
+
+        Ok(())
+    }
+
+    pub async fn get_roles(pool: &PgPool, user_id: &uuid::Uuid) -> Result<Roles, sqlx::Error> {
+        let roles = sqlx::query_scalar!(
+            "
+                SELECT roles FROM users_members INNER JOIN members ON users_members.member_id = members.member_id AND users_members.user_id = $1;
+            ",
+            user_id
+        ).fetch_all(pool).await?;
+
+        let roles: Vec<Roles> = roles.into_iter().map(|r| r.into()).collect();
+        let roles = roles
+            .into_iter()
+            .fold(Roles::empty(), |acc, flag| acc | flag);
+
+        Ok(roles)
+    }
+
+    pub async fn get_roles_groups(
+        pool: &PgPool,
+        user_id: &uuid::Uuid,
+    ) -> Result<(Roles, Groups), sqlx::Error> {
+        struct RolesGroups {
+            roles: i64,
+            groups: i64,
+        }
+
+        let result = sqlx::query_as!(
+            RolesGroups,
+            "
+                SELECT roles, groups
+                FROM users_members
+                INNER JOIN members ON users_members.member_id = members.member_id
+                AND users_members.user_id = $1;
+            ",
+            user_id,
+        )
+        .fetch_all(pool)
+        .await?;
+
+        let (roles, groups) = result.into_iter().fold(
+            (Roles::empty(), Groups::empty()),
+            |(acc_roles, acc_groups), r| (acc_roles | r.roles.into(), acc_groups | r.groups.into()),
+        );
+
+        Ok((roles, groups))
+    }
+
+    pub async fn get_members_from_user(
+        pool: &PgPool,
+        user_id: &uuid::Uuid,
+    ) -> Result<Vec<DbMember>, sqlx::Error> {
+        let members = sqlx::query_as!(DbMember,
+            "
+                SELECT members.* FROM users_members INNER JOIN members ON users_members.member_id = members.member_id AND users_members.user_id = $1;
+            ",
+            user_id
+        ).fetch_all(pool).await?;
+
+        Ok(members)
+    }
+
+    pub async fn remove_many(
+        transaction: &mut sqlx::Transaction<'_, Postgres>,
+        user_ids: &[uuid::Uuid],
+        member_ids: &[String],
+    ) -> Result<(), sqlx::Error> {
+        let deleted_count = sqlx::query_scalar!(
+            "
+                WITH deleted AS (
+                    DELETE FROM users_members
+                    WHERE user_id = ANY($1) AND member_id = ANY($2)
+                    RETURNING 1
+                )
+                SELECT COUNT(*) FROM deleted
+            ",
+            &user_ids[..],
+            &member_ids[..]
+        )
+        .fetch_one(&mut **transaction)
+        .await?;
+
+        if !deleted_count.is_some_and(|c| c >= 1) {
+            return Err(sqlx::Error::RowNotFound);
+        }
+
+        Ok(())
+    }
+}

server/src/database/postgres.rs

@@ -0,0 +1,37 @@
+use sqlx::{
+    migrate::MigrateDatabase, postgres::PgPoolOptions, Connection, PgConnection, PgPool, Postgres,
+};
+
+pub async fn connect() -> Result<PgPool, sqlx::Error> {
+    tracing::info!("Initializing database connection");
+
+    let database_url =
+        dotenvy::var("DATABASE_URL").expect("`DATABASE_URL` environment variable not set");
+
+    let pool = PgPoolOptions::new()
+        .max_connections(5)
+        .connect(&database_url)
+        .await?;
+
+    Ok(pool)
+}
+
+pub async fn apply_migrations() -> Result<(), sqlx::Error> {
+    let uri = dotenvy::var("DATABASE_URL").expect("`DATABASE_URL` environment variable not set");
+    let uri = uri.as_str();
+
+    if !Postgres::database_exists(uri).await? {
+        tracing::info!("Creating database...");
+        Postgres::create_database(uri).await?;
+    }
+
+    tracing::info!("Applying migrations...");
+
+    let mut conn = PgConnection::connect(uri).await?;
+    sqlx::migrate!()
+        .run(&mut conn)
+        .await
+        .expect("Error while running database migrations");
+
+    Ok(())
+}

server/src/lib.rs

@@ -0,0 +1,18 @@
+use routes::member::migrate::MigrationStore;
+use sqlx::{Pool, Postgres};
+use std::sync::Arc;
+use tokio::sync::Mutex;
+
+pub mod auth;
+pub mod database;
+pub mod model;
+pub mod routes;
+pub mod util;
+
+pub use util::error::Error;
+
+#[derive(Clone)]
+pub struct AppState {
+    pub pool: Pool<Postgres>,
+    pub migration_store: Arc<Mutex<MigrationStore>>,
+}

server/src/main.rs

@@ -0,0 +1,28 @@
+use tracing::Level;
+use tracing_subscriber::FmtSubscriber;
+
+use wrbapp_server::database;
+
+#[tokio::main]
+async fn main() {
+    dotenvy::dotenv().ok();
+
+    // Initialize logging
+    let subscriber = FmtSubscriber::builder()
+        .with_max_level(Level::INFO)
+        .finish();
+
+    tracing::subscriber::set_global_default(subscriber)
+        .expect("Error while initialized tracing subscriber");
+
+    // Initialize database connection
+    database::apply_migrations()
+        .await
+        .expect("Database migrations failed");
+
+    let pool = database::connect()
+        .await
+        .expect("Database connection failed");
+
+    wrbapp_server::util::cli::parse(pool).await;
+}

server/src/model.rs

@@ -0,0 +1,8 @@
+pub mod member;
+pub mod message;
+pub mod session;
+pub mod user;
+
+pub use member::Member;
+pub use message::Message;
+pub use user::User;

server/src/model/member.rs

@@ -0,0 +1,160 @@
+use bitflags::bitflags;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Name {
+    pub first: String,
+    pub full: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Member {
+    pub id: String,
+    pub name: Name,
+    pub registration_token: Option<String>,
+    pub diploma: Option<String>,
+    pub groups: Groups,
+    pub roles: Roles,
+}
+
+bitflags! {
+    #[derive(Clone, Copy, Debug, Serialize, Deserialize)]
+    pub struct Roles: u64 {
+        const MEMBER = 1 << 0;
+        const KADER = 1 << 1;
+        const ZWEMZAKEN = 1 << 2;
+        const WEDSTRIJDEN = 1 << 3;
+        const ADMIN = 1 << 4;
+        const MESSAGES = 1 << 5;
+    }
+
+    #[derive(Clone, Copy, Debug, Serialize, Deserialize)]
+    pub struct Groups: u64 {
+        const NONE = 1 << 0;
+
+        const A1 = 1 << 1;
+        const A2 = 1 << 2;
+        const A3 = 1 << 3;
+        const A4 = 1 << 4;
+        const A5 = 1 << 5;
+        const A6 = 1 << 6;
+
+        const B1 = 1 << 7;
+        const B2 = 1 << 8;
+        const B3 = 1 << 9;
+        const B4 = 1 << 10;
+        const B5 = 1 << 11;
+        const B6 = 1 << 12;
+
+        const C1 = 1 << 13;
+        const C2 = 1 << 14;
+        const C3 = 1 << 15;
+        const C4 = 1 << 16;
+        const C5 = 1 << 17;
+        const C6 = 1 << 18;
+
+        const D1 = 1 << 19;
+        const D2 = 1 << 20;
+        const D3 = 1 << 21;
+        const D4 = 1 << 22;
+        const D5 = 1 << 23;
+        const D6 = 1 << 24;
+
+        const E1 = 1 << 25;
+        const E2 = 1 << 26;
+        const E3 = 1 << 27;
+        const E4 = 1 << 28;
+        const E5 = 1 << 29;
+        const E6 = 1 << 30;
+
+        const Z1 = 1 << 31;
+        const Z2 = 1 << 32;
+        const Z3 = 1 << 33;
+        const Z4 = 1 << 34;
+        const Z5 = 1 << 35;
+        const Z6 = 1 << 36;
+
+        const WEDSTRIJD = 1 << 37;
+    }
+}
+
+impl From<i64> for Groups {
+    fn from(value: i64) -> Self {
+        Self::from_bits(value as u64).unwrap_or(Groups::empty())
+    }
+}
+
+impl From<Option<Groups>> for Groups {
+    fn from(value: Option<Groups>) -> Self {
+        match value {
+            Some(groups) => groups,
+            None => Self::empty(),
+        }
+    }
+}
+
+impl Groups {
+    pub fn to_option(self) -> Option<Self> {
+        if self.is_empty() {
+            None
+        } else {
+            Some(self)
+        }
+    }
+}
+
+impl From<i64> for Roles {
+    fn from(value: i64) -> Self {
+        Self::from_bits(value as u64).unwrap_or(Roles::empty())
+    }
+}
+
+impl From<Option<Roles>> for Roles {
+    fn from(value: Option<Roles>) -> Self {
+        match value {
+            Some(roles) => roles,
+            None => Self::empty(),
+        }
+    }
+}
+
+impl Roles {
+    pub fn to_option(self) -> Option<Self> {
+        if self.is_empty() {
+            None
+        } else {
+            Some(self)
+        }
+    }
+}
+
+use crate::database::model::Member as DbMember;
+impl From<DbMember> for Member {
+    fn from(value: DbMember) -> Self {
+        Member {
+            id: value.member_id,
+            name: Name {
+                first: value.first_name,
+                full: value.full_name,
+            },
+            registration_token: value.registration_token,
+            diploma: value.diploma,
+            groups: value.groups,
+            roles: value.roles,
+        }
+    }
+}
+
+impl From<Member> for DbMember {
+    fn from(value: Member) -> Self {
+        DbMember {
+            member_id: value.id,
+            first_name: value.name.first,
+            full_name: value.name.full,
+            registration_token: None,
+            diploma: value.diploma,
+            groups: value.groups,
+            roles: value.roles,
+        }
+    }
+}

server/src/model/message.rs

@@ -0,0 +1,136 @@
+use bitflags::bitflags;
+use chrono::{DateTime, Utc};
+use serde::Serialize;
+
+#[derive(Debug, Serialize)]
+pub struct Message {
+    pub message_id: uuid::Uuid,
+    pub created_at: DateTime<Utc>,
+    pub scheduled_at: Option<DateTime<Utc>>,
+    pub status: MessageStatus,
+    pub title: String,
+    pub content: String,
+    pub channel: Channel,
+    pub member_groups: Groups,
+    pub member_roles: Roles,
+    pub thumbnail_url: Option<String>,
+}
+
+#[derive(Debug, Clone, Copy, sqlx::Type, Serialize)]
+#[sqlx(type_name = "message_status", rename_all = "lowercase")]
+pub enum MessageStatus {
+    Pending,
+    Sent,
+    Canceled,
+    Draft,
+}
+
+bitflags! {
+    #[derive(Clone, Copy, Debug, Serialize)]
+    pub struct Channel: u16 {
+        const ALGEMEEN = 1 << 0;
+        const BELANGRIJK = 1 << 1;
+        const WEDSTRIJDEN = 1 << 2;
+    }
+}
+
+impl From<i64> for Channel {
+    fn from(value: i64) -> Self {
+        Self::from_bits(value as u16).unwrap_or(Channel::empty())
+    }
+}
+
+pub struct MessageCreate {
+    pub scheduled_at: Option<DateTime<Utc>>,
+    pub title: String,
+    pub content: String,
+    pub channel: String,
+    pub member_groups: String,
+    pub member_roles: String,
+    pub thumbnail_url: Option<String>,
+}
+
+impl Message {
+    pub fn new(message_create: MessageCreate) -> Result<Self, crate::Error> {
+        let message_id = uuid::Uuid::new_v4();
+
+        let created_at = Utc::now();
+
+        let channel: Channel =
+            bitflags::parser::from_str_strict(&message_create.channel).map_err(|_| {
+                crate::Error::BadRequest {
+                    expected: String::from("Error while parsing channel"),
+                }
+            })?;
+
+        let member_groups = if message_create.member_groups.is_empty() {
+            Ok(Groups::all())
+        } else {
+            bitflags::parser::from_str_strict(&message_create.member_groups).map_err(|_| {
+                crate::Error::BadRequest {
+                    expected: "Error while parsing groups".to_string(),
+                }
+            })
+        }?;
+
+        let member_roles = if message_create.member_roles.is_empty() {
+            Ok(Roles::all())
+        } else {
+            bitflags::parser::from_str_strict(&message_create.member_roles).map_err(|_| {
+                crate::Error::BadRequest {
+                    expected: "Error while parsing groups".to_string(),
+                }
+            })
+        }?;
+
+        Ok(Self {
+            message_id,
+            created_at,
+            scheduled_at: message_create.scheduled_at,
+            title: message_create.title,
+            content: message_create.content,
+            channel,
+            thumbnail_url: message_create.thumbnail_url,
+            member_groups,
+            member_roles,
+            status: MessageStatus::Draft,
+        })
+    }
+}
+
+use crate::database::model::Message as DbMessage;
+
+use super::member::{Groups, Roles};
+impl From<DbMessage> for Message {
+    fn from(value: DbMessage) -> Self {
+        Self {
+            message_id: value.message_id,
+            created_at: value.created_at,
+            scheduled_at: value.scheduled_at,
+            status: value.status,
+            title: value.title,
+            content: value.content,
+            channel: value.channel,
+            member_groups: value.member_groups,
+            member_roles: value.member_roles,
+            thumbnail_url: value.thumbnail_url,
+        }
+    }
+}
+
+impl From<Message> for DbMessage {
+    fn from(value: Message) -> Self {
+        Self {
+            message_id: value.message_id,
+            created_at: value.created_at,
+            scheduled_at: value.scheduled_at,
+            status: value.status,
+            title: value.title,
+            content: value.content,
+            channel: value.channel,
+            member_groups: value.member_groups,
+            member_roles: value.member_roles,
+            thumbnail_url: value.thumbnail_url,
+        }
+    }
+}

server/src/model/session.rs

@@ -0,0 +1,55 @@
+use chrono::{DateTime, Duration, Utc};
+
+use crate::auth::generate_session_token;
+
+#[derive(Debug)]
+pub struct Session {
+    pub session_id: uuid::Uuid,
+    pub user_id: uuid::Uuid,
+    pub token: String,
+    pub expires_at: DateTime<Utc>,
+    pub created_at: DateTime<Utc>,
+}
+
+impl Session {
+    pub fn new(user_id: uuid::Uuid) -> Self {
+        let session_id = uuid::Uuid::new_v4();
+        let token = generate_session_token();
+
+        let created_at = Utc::now();
+        let expires_at = Utc::now() + Duration::days(7);
+
+        Self {
+            session_id,
+            user_id,
+            token,
+            expires_at,
+            created_at,
+        }
+    }
+}
+
+use crate::database::model::Session as DbSession;
+impl From<DbSession> for Session {
+    fn from(db_session: DbSession) -> Self {
+        Self {
+            session_id: db_session.session_id,
+            user_id: db_session.user_id,
+            token: db_session.token,
+            expires_at: db_session.expires_at,
+            created_at: db_session.created_at,
+        }
+    }
+}
+
+impl From<Session> for DbSession {
+    fn from(session: Session) -> Self {
+        Self {
+            session_id: session.session_id,
+            user_id: session.user_id,
+            token: session.token,
+            expires_at: session.expires_at,
+            created_at: session.created_at,
+        }
+    }
+}

server/src/model/user.rs

@@ -0,0 +1,80 @@
+use serde::Serialize;
+use sqlx::PgPool;
+
+#[derive(Serialize)]
+pub struct User {
+    pub id: uuid::Uuid,
+    pub email: String,
+    pub admin: bool,
+}
+
+use crate::auth::AuthError;
+use crate::database::model::User as DbUser;
+use crate::database::model::UserMember as DbUserMember;
+use crate::util::convert_vec;
+
+use super::member::Groups;
+use super::member::Roles;
+use super::Member;
+impl From<DbUser> for User {
+    fn from(db_user: DbUser) -> Self {
+        Self {
+            id: db_user.user_id,
+            email: db_user.email,
+            admin: db_user.admin,
+        }
+    }
+}
+
+impl From<User> for DbUser {
+    fn from(user: User) -> Self {
+        Self {
+            user_id: user.id,
+            email: user.email,
+            admin: user.admin,
+            password: None,
+        }
+    }
+}
+
+impl User {
+    pub async fn members(&self, pool: &PgPool) -> Result<Vec<Member>, sqlx::Error> {
+        let related_members = DbUserMember::get_members_from_user(pool, &self.id).await?;
+
+        Ok(convert_vec(related_members))
+    }
+
+    pub async fn authorize(
+        &self,
+        pool: &PgPool,
+        required_roles: Option<Roles>,
+        requested_user_id: Option<String>,
+    ) -> Result<(), AuthError> {
+        if let Some(user_id) = requested_user_id {
+            let user_uuid = uuid::Uuid::parse_str(&user_id).map_err(|_| AuthError::NoPermssions)?;
+
+            if self.id != user_uuid {
+                return Err(AuthError::NoPermssions);
+            }
+
+            return Ok(());
+        }
+
+        if let Some(roles) = required_roles {
+            let user_roles = DbUserMember::get_roles(pool, &self.id)
+                .await
+                .unwrap_or(Roles::MEMBER);
+            if !user_roles.intersects(roles) {
+                return Err(AuthError::NoPermssions);
+            }
+
+            return Ok(());
+        }
+
+        Ok(())
+    }
+
+    pub async fn get_roles_groups(&self, pool: &PgPool) -> Result<(Roles, Groups), sqlx::Error> {
+        DbUserMember::get_roles_groups(pool, &self.id).await
+    }
+}

server/src/routes.rs

@@ -0,0 +1,25 @@
+use crate::{auth::get_user_from_header, model::User, AppState};
+use axum::{extract::State, http::HeaderMap, routing::get, Json, Router};
+
+pub mod auth;
+pub mod member;
+pub mod message;
+pub mod user;
+
+pub fn routes() -> Router<AppState> {
+    Router::new()
+        .route("/", get(root))
+        .merge(member::routes())
+        .merge(auth::routes())
+        .merge(user::routes())
+        .merge(message::routes())
+}
+
+async fn root(
+    State(state): State<AppState>,
+    headers: HeaderMap,
+) -> Result<Json<User>, crate::Error> {
+    let user = get_user_from_header(&state.pool, &headers).await?;
+
+    Ok(Json(user))
+}

server/src/routes/auth.rs

@@ -0,0 +1,181 @@
+use axum::http::HeaderMap;
+use axum::{
+    extract::State,
+    routing::{get, post},
+    Json, Router,
+};
+use serde::Deserialize;
+
+use crate::auth::{get_token_from_headers, verify_password_hash};
+use crate::auth::{get_user_from_header, AuthError};
+use crate::database::model::user::UpdateUser;
+use crate::database::model::Member as DbMember;
+use crate::database::model::Session as DbSession;
+use crate::database::model::User as DbUser;
+use crate::database::model::UserMember as DbUserMember;
+use crate::model::session::Session;
+use crate::{auth::generate_password_hash, AppState};
+
+pub fn routes() -> Router<AppState> {
+    Router::new()
+        .route("/auth/login", post(login))
+        .route("/auth/register", post(register))
+        .route("/auth/logout", get(logout))
+        .route("/auth/change_password", post(change_password))
+        .route("/auth/change_email", post(change_email))
+}
+
+#[derive(Deserialize)]
+pub struct LoginRequest {
+    email: String,
+    password: String,
+}
+
+pub async fn login(
+    State(state): State<AppState>,
+    Json(login_request): Json<LoginRequest>,
+) -> Result<String, crate::Error> {
+    let db_user = DbUser::get_from_email(&state.pool, login_request.email).await?;
+
+    if let Some(pass) = db_user.password {
+        verify_password_hash(&login_request.password, &pass).await?;
+    } else {
+        return Err(AuthError::Unexpected.into());
+    }
+
+    // Create session
+    let mut transaction = state.pool.begin().await?;
+
+    let db_session: DbSession = Session::new(db_user.user_id).into();
+    db_session.insert(&mut transaction).await?;
+
+    transaction.commit().await?;
+
+    Ok(db_session.token)
+}
+
+#[derive(Deserialize)]
+pub struct RegisterRequest {
+    email: String,
+    password: String,
+    registration_tokens: Vec<String>,
+}
+
+pub async fn register(
+    State(state): State<AppState>,
+    Json(auth_request): Json<RegisterRequest>,
+) -> Result<String, crate::Error> {
+    // Get all the members to link with the user
+    let members =
+        DbMember::get_many_from_registration_tokens(&state.pool, auth_request.registration_tokens)
+            .await?;
+
+    let member_ids: Vec<String> = members.into_iter().map(|m| m.member_id).collect();
+
+    // Hash password
+    let password_hash = generate_password_hash(auth_request.password).await?;
+
+    let mut transaction = state.pool.begin().await?;
+
+    // Insert the user to the database
+    let user_id = DbUser::insert(&mut transaction, &auth_request.email, &password_hash).await?;
+
+    // Link the user to the members
+    let user_ids: Vec<uuid::Uuid> = vec![user_id; member_ids.len()];
+    DbUserMember::insert_many(&mut transaction, &user_ids, &member_ids).await?;
+
+    // Create a new session
+    let db_session: DbSession = Session::new(user_id).into();
+    db_session.insert(&mut transaction).await?;
+
+    transaction.commit().await?;
+
+    Ok(db_session.token)
+}
+
+pub async fn logout(State(state): State<AppState>, headers: HeaderMap) -> Result<(), crate::Error> {
+    let registration_token = get_token_from_headers(&headers)?;
+
+    let mut transaction = state.pool.begin().await?;
+
+    DbSession::remove_many_from_token(&mut transaction, &[registration_token]).await?;
+
+    transaction.commit().await?;
+
+    Ok(())
+}
+
+#[derive(Debug, Deserialize)]
+pub struct ChangePasswordRequest {
+    pub old_password: String,
+    pub new_password: String,
+}
+
+pub async fn change_password(
+    State(state): State<AppState>,
+    headers: HeaderMap,
+    Json(request): Json<ChangePasswordRequest>,
+) -> Result<(), crate::Error> {
+    let user = get_user_from_header(&state.pool, &headers).await?;
+
+    // Verify that password is correct
+    let db_user: DbUser = user.into();
+    let old_password_hash = db_user.get_password(&state.pool).await?;
+    verify_password_hash(&request.old_password, &old_password_hash).await?;
+
+    // Generate password hash for new password
+    let new_password_hash = generate_password_hash(request.new_password).await?;
+
+    let mut transaction = state.pool.begin().await?;
+
+    db_user
+        .update(
+            &mut transaction,
+            UpdateUser {
+                email: None,
+                password: Some(new_password_hash),
+                admin: None,
+            },
+        )
+        .await?;
+
+    transaction.commit().await?;
+
+    Ok(())
+}
+
+#[derive(Debug, Deserialize)]
+pub struct ChangeEmailRequest {
+    pub password: String,
+    pub new_email: String,
+}
+
+pub async fn change_email(
+    State(state): State<AppState>,
+    headers: HeaderMap,
+    Json(request): Json<ChangeEmailRequest>,
+) -> Result<(), crate::Error> {
+    let user = get_user_from_header(&state.pool, &headers).await?;
+
+    // Verify that password is correct
+    let db_user: DbUser = user.into();
+    let password_hash = db_user.get_password(&state.pool).await?;
+    verify_password_hash(&request.password, &password_hash).await?;
+
+    let mut transaction = state.pool.begin().await?;
+
+    db_user
+        .update(
+            &mut transaction,
+            UpdateUser {
+                email: Some(request.new_email),
+                password: None,
+                admin: None,
+            },
+        )
+        .await?;
+
+    transaction.commit().await?;
+
+    Ok(())
+}

server/src/routes/member.rs

@@ -0,0 +1,28 @@
+use axum::{
+    extract::State,
+    http::HeaderMap,
+    routing::{get, post},
+    Json, Router,
+};
+
+use crate::{auth::get_user_from_header, model::Member, AppState};
+
+pub mod migrate;
+
+pub fn routes() -> Router<AppState> {
+    Router::new()
+        .route("/members/migrate_request", post(migrate::migrate_request))
+        .route("/members/migrate_confirm", post(migrate::migrate_confirm))
+        .route("/member", get(get_current_members))
+}
+
+pub async fn get_current_members(
+    State(state): State<AppState>,
+    headers: HeaderMap,
+) -> Result<Json<Vec<Member>>, crate::Error> {
+    let user = get_user_from_header(&state.pool, &headers).await?;
+
+    let members = user.members(&state.pool).await?;
+
+    Ok(Json(members))
+}

server/src/routes/member/migrate.rs

@@ -0,0 +1,275 @@
+use std::collections::HashMap;
+
+use axum::{extract::State, http::HeaderMap, Json};
+use sqlx::PgPool;
+
+use crate::{
+    auth::get_user_from_header,
+    database::model::Member as DbMember,
+    model::{
+        member::{Groups, Name, Roles},
+        Member,
+    },
+    util::convert_vec,
+    AppState,
+};
+
+pub async fn migrate_request(
+    State(state): State<AppState>,
+    headers: HeaderMap,
+    body: String,
+) -> Result<Json<MigrationResponse>, crate::Error> {
+    let user = get_user_from_header(&state.pool, &headers).await?;
+
+    user.authorize(&state.pool, Some(Roles::ADMIN), None)
+        .await?;
+
+    tracing::info!("Migration is requested");
+
+    // Convert the input CSV to a vector of members
+    let members_new: Vec<Member> = Row::from_csv_many(&body)?
+        .into_iter()
+        .map(|m| m.into())
+        .collect();
+
+    let members_old = convert_vec(DbMember::get_all(&state.pool).await?);
+
+    let members_diff = generate_diff(members_new, members_old);
+
+    let count = state
+        .migration_store
+        .lock()
+        .await
+        .insert(members_diff.clone());
+
+    Ok(Json(MigrationResponse::from((count, members_diff))))
+}
+
+pub async fn migrate_confirm(
+    State(state): State<AppState>,
+    headers: HeaderMap,
+    body: String,
+) -> Result<(), crate::Error> {
+    let user = get_user_from_header(&state.pool, &headers).await?;
+    user.authorize(&state.pool, Some(Roles::ADMIN), None)
+        .await?;
+
+    tracing::info!("Migration is confirmed");
+
+    let count = match body.trim().parse::<u32>() {
+        Ok(c) => c,
+        Err(_) => {
+            return Err(crate::Error::BadRequest {
+                expected: String::from("u32"),
+            })
+        }
+    };
+
+    let mut store = state.migration_store.lock().await;
+
+    let members_diff = match store.remove(&count) {
+        Some(m) => m,
+        None => return Err(crate::Error::NotFound),
+    };
+
+    let inserted_len = members_diff.insert.len();
+    let update_len = members_diff.update.len();
+    let remove_len = members_diff.remove.len();
+
+    migrate_transaction(&state.pool, members_diff).await?;
+
+    tracing::info!(
+        "Migration is successfully executed. Inserted: {}, updated: {}, removed: {}",
+        inserted_len,
+        update_len,
+        remove_len
+    );
+
+    Ok(())
+}
+
+async fn migrate_transaction(pool: &PgPool, members_diff: MembersDiff) -> Result<(), sqlx::Error> {
+    let mut transaction = pool.begin().await?;
+
+    DbMember::insert_many(&mut transaction, convert_vec(members_diff.insert)).await?;
+    DbMember::update_many(&mut transaction, convert_vec(members_diff.update)).await?;
+
+    let members_remove_ids: Vec<String> = members_diff.remove.into_iter().map(|m| m.id).collect();
+    DbMember::remove_many(&mut transaction, &members_remove_ids).await?;
+
+    transaction.commit().await?;
+
+    Ok(())
+}
+
+// Create a row for the csv file
+#[derive(Debug, serde::Deserialize, Clone)]
+struct Row {
+    #[serde(rename = "Relatiecode")]
+    id: String,
+    #[serde(rename = "Roepnaam")]
+    first_name: String,
+    // #[serde(rename = "Tussenvoegsel(s)")]
+    // middle_name: String,
+    // #[serde(rename = "Achternaam")]
+    // last_name: String,
+    #[serde(rename = "E-mail")]
+    email: String,
+    #[serde(rename = "Verenigingssporten")]
+    groups: String,
+    #[serde(rename = "Diploma dropdown 1")]
+    diploma: Option<String>,
+}
+
+#[derive(Debug, Clone)]
+pub struct MembersDiff {
+    insert: Vec<Member>,
+    update: Vec<Member>,
+    remove: Vec<Member>,
+}
+
+#[derive(serde::Serialize)]
+pub struct MigrationResponse {
+    count: u32,
+    insert: Vec<(String, Name)>,
+    update: Vec<(String, Name)>,
+    remove: Vec<(String, Name)>,
+}
+
+#[derive(Default)]
+pub struct MigrationStore {
+    pub store: HashMap<u32, MembersDiff>,
+    pub count: u32,
+}
+
+impl Row {
+    fn from_csv_many(input: &str) -> Result<Vec<Self>, csv::Error> {
+        let mut rdr = csv::ReaderBuilder::new()
+            .delimiter(b';')
+            .from_reader(input.as_bytes());
+
+        let members: Result<Vec<Row>, csv::Error> = rdr.deserialize().collect();
+
+        members
+    }
+
+    fn groups_parsed(&self) -> Groups {
+        let mut groups: Vec<String> = Vec::new();
+
+        let group_parts: Vec<&str> = self.groups.split(", ").collect();
+
+        for group in group_parts {
+            let hour_parts: Vec<&str> = group.split(" - ").collect();
+
+            if let Some(group) = hour_parts.get(1) {
+                groups.push(group.to_uppercase())
+            }
+        }
+
+        let groups_string = groups.join("|");
+
+        bitflags::parser::from_str(&groups_string).unwrap_or(Groups::empty())
+    }
+}
+
+impl From<Row> for Name {
+    fn from(val: Row) -> Self {
+        Name {
+            first: val.first_name,
+            full: "Temporarely full name".to_string(),
+        }
+    }
+}
+
+impl From<Row> for Member {
+    fn from(val: Row) -> Self {
+        let name: Name = val.clone().into();
+
+        Member {
+            id: val.id.clone(),
+            name,
+            registration_token: None,
+            diploma: val.diploma.clone(),
+            groups: val.groups_parsed(),
+            roles: Roles::MEMBER,
+        }
+    }
+}
+
+impl From<(u32, MembersDiff)> for MigrationResponse {
+    fn from(value: (u32, MembersDiff)) -> Self {
+        let members_insert: Vec<(String, Name)> =
+            value.1.insert.into_iter().map(|m| (m.id, m.name)).collect();
+        let members_update: Vec<(String, Name)> =
+            value.1.update.into_iter().map(|m| (m.id, m.name)).collect();
+        let members_remove: Vec<(String, Name)> =
+            value.1.remove.into_iter().map(|m| (m.id, m.name)).collect();
+
+        Self {
+            count: value.0,
+            insert: members_insert,
+            update: members_update,
+            remove: members_remove,
+        }
+    }
+}
+
+impl MigrationStore {
+    fn insert(&mut self, members_diff: MembersDiff) -> u32 {
+        let count = self.count + 1;
+        self.store.insert(count, members_diff);
+        self.count = count;
+        count
+    }
+
+    fn get(&self, id: &u32) -> Option<&MembersDiff> {
+        self.store.get(id)
+    }
+
+    fn remove(&mut self, id: &u32) -> Option<MembersDiff> {
+        self.store.remove(id)
+    }
+}
+
+fn generate_diff(members_new: Vec<Member>, members_old: Vec<Member>) -> MembersDiff {
+    let members_old_map: HashMap<String, Member> = members_old
+        .iter()
+        .map(|m| (m.id.clone(), m.clone()))
+        .collect();
+
+    let members_new_map: HashMap<String, Member> = members_new
+        .iter()
+        .map(|m| (m.id.clone(), m.clone()))
+        .collect();
+
+    let mut members_insert: Vec<Member> = Vec::new();
+    let mut members_update: Vec<Member> = Vec::new();
+    let mut members_remove: Vec<Member> = Vec::new();
+
+    for old_member in members_old {
+        if let Some(new_member) = members_new_map.get(&old_member.id) {
+            members_update.push(Member {
+                id: old_member.id,
+                name: new_member.name.clone(),
+                registration_token: old_member.registration_token,
+                diploma: new_member.diploma.clone(),
+                groups: new_member.groups,
+                roles: old_member.roles,
+            })
+        } else {
+            members_remove.push(old_member);
+        }
+    }
+
+    for new_member in members_new {
+        if !members_old_map.contains_key(&new_member.id) {
+            members_insert.push(new_member);
+        }
+    }
+
+    MembersDiff {
+        insert: members_insert,
+        update: members_update,
+        remove: members_remove,
+    }
+}

server/src/routes/message.rs

@@ -0,0 +1,87 @@
+use axum::{
+    extract::{Path, State},
+    http::HeaderMap,
+    routing::post,
+    Json, Router,
+};
+use serde::Deserialize;
+
+use crate::{
+    auth::get_user_from_header,
+    database::model::Message as DbMessage,
+    model::{
+        member::Roles,
+        message::{MessageCreate, MessageStatus},
+        Message,
+    },
+    AppState,
+};
+
+pub fn routes() -> Router<AppState> {
+    Router::new()
+        .route("/messages", post(message_create))
+        .route("/messages/{message_id}/send", post(message_send))
+}
+
+#[derive(Debug, Deserialize)]
+pub struct MessageCreateRequest {
+    title: String,
+    content: String,
+    channel: String,
+    member_groups: String,
+    member_roles: String,
+}
+
+pub async fn message_create(
+    State(state): State<AppState>,
+    headers: HeaderMap,
+    Json(request): Json<MessageCreateRequest>,
+) -> Result<String, crate::Error> {
+    let user = get_user_from_header(&state.pool, &headers).await?;
+
+    user.authorize(&state.pool, Some(Roles::ADMIN | Roles::MESSAGES), None)
+        .await?;
+
+    let db_message: DbMessage = Message::new(MessageCreate {
+        title: request.title,
+        content: request.content,
+        channel: request.channel,
+        member_groups: request.member_groups,
+        member_roles: request.member_roles,
+        scheduled_at: None,
+        thumbnail_url: None,
+    })?
+    .into();
+
+    let mut transaction = state.pool.begin().await?;
+
+    db_message.insert(&mut transaction).await?;
+
+    transaction.commit().await?;
+
+    Ok(db_message.message_id.to_string())
+}
+
+pub async fn message_send(
+    State(state): State<AppState>,
+    headers: HeaderMap,
+    Path(message_id): Path<String>,
+) -> Result<(), crate::Error> {
+    let user = get_user_from_header(&state.pool, &headers).await?;
+
+    user.authorize(&state.pool, Some(Roles::ADMIN | Roles::MESSAGES), None)
+        .await?;
+
+    let message_id: uuid::Uuid =
+        uuid::Uuid::parse_str(&message_id).map_err(|_| crate::Error::BadRequest {
+            expected: "Could not convert message id to uuid".to_string(),
+        })?;
+
+    let mut transaction = state.pool.begin().await?;
+
+    DbMessage::update_status(&mut transaction, &message_id, MessageStatus::Sent).await?;
+
+    transaction.commit().await?;
+
+    Ok(())
+}

server/src/routes/user.rs

@@ -0,0 +1,91 @@
+use axum::{
+    extract::{Path, State},
+    http::HeaderMap,
+    routing::{delete, get, post},
+    Json, Router,
+};
+
+use crate::{
+    auth::get_user_from_header,
+    database::model::{Member as DbMember, Message as DbMessage, UserMember as DbUserMember},
+    model::{member::Roles, message::Channel, Member, Message, User},
+    util::convert_vec,
+    AppState,
+};
+
+pub fn routes() -> Router<AppState> {
+    Router::new()
+        .route("/user", get(get_current_user))
+        .route("/user/{user_id}/members", post(members_insert))
+        .route("/user/{user_id}/members", delete(members_remove))
+        .route("/user/{user_id}/messages", get(get_messages))
+}
+
+pub async fn get_current_user(
+    State(state): State<AppState>,
+    headers: HeaderMap,
+) -> Result<Json<User>, crate::Error> {
+    let user = get_user_from_header(&state.pool, &headers).await?;
+    Ok(Json(user))
+}
+
+pub async fn members_insert(
+    State(state): State<AppState>,
+    Path(user_id): Path<String>,
+    headers: HeaderMap,
+    Json(registration_tokens): Json<Vec<String>>,
+) -> Result<Json<Vec<Member>>, crate::Error> {
+    let user = get_user_from_header(&state.pool, &headers).await?;
+    user.authorize(&state.pool, Some(Roles::ADMIN), Some(user_id))
+        .await?;
+
+    let members =
+        DbMember::get_many_from_registration_tokens(&state.pool, registration_tokens).await?;
+
+    let member_ids: Vec<String> = members.iter().map(|m| m.member_id.to_owned()).collect();
+
+    let mut transaction = state.pool.begin().await?;
+
+    // Link the user to the members
+    let user_ids: Vec<uuid::Uuid> = vec![user.id; member_ids.len()];
+    DbUserMember::insert_many(&mut transaction, &user_ids, &member_ids).await?;
+
+    transaction.commit().await?;
+
+    Ok(Json(convert_vec(members)))
+}
+
+pub async fn members_remove(
+    State(state): State<AppState>,
+    Path(user_id): Path<String>,
+    headers: HeaderMap,
+    Json(member_ids): Json<Vec<String>>,
+) -> Result<(), crate::Error> {
+    let user = get_user_from_header(&state.pool, &headers).await?;
+    user.authorize(&state.pool, Some(Roles::ADMIN), Some(user_id))
+        .await?;
+
+    let mut transaction = state.pool.begin().await?;
+
+    // Link the user to the members
+    DbUserMember::remove_many(&mut transaction, &[user.id], &member_ids).await?;
+
+    transaction.commit().await?;
+
+    Ok(())
+}
+
+pub async fn get_messages(
+    State(state): State<AppState>,
+    Path(user_id): Path<String>,
+    headers: HeaderMap,
+) -> Result<Json<Vec<Message>>, crate::Error> {
+    let user = get_user_from_header(&state.pool, &headers).await?;
+    user.authorize(&state.pool, None, Some(user_id)).await?;
+
+    let (roles, groups) = user.get_roles_groups(&state.pool).await?;
+
+    let messages = DbMessage::get(&state.pool, Channel::ALGEMEEN, roles, groups).await?;
+
+    Ok(Json(convert_vec(messages)))
+}

server/src/util.rs

@@ -0,0 +1,7 @@
+mod bitflags;
+pub mod cli;
+pub mod error;
+mod helpers;
+pub mod serve;
+
+pub use helpers::convert_vec;

server/src/util/bitflags.rs

@@ -0,0 +1,18 @@
+#[macro_export]
+macro_rules! bitflags_serde_impl {
+    ($type:ident, $int_type:ident) => {
+        impl serde::Serialize for $type {
+            fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+                serializer.serialize_i64(self.bits() as i64)
+            }
+        }
+
+        impl<'de> serde::Deserialize<'de> for $type {
+            fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+                let v: i64 = Deserialize::deserialize(deserializer)?;
+
+                Ok($type::from_bits_truncate(v as $int_type))
+            }
+        }
+    };
+}

server/src/util/cli.rs

@@ -0,0 +1,73 @@
+use clap::{Parser, Subcommand};
+use sqlx::{Acquire, PgPool};
+
+use crate::model::member::{Groups, Roles};
+
+#[derive(Parser)]
+#[command(version, about, long_about = None)]
+struct Cli {
+    #[command(subcommand)]
+    command: Option<Commands>,
+}
+
+#[derive(Subcommand)]
+enum Commands {
+    Serve,
+    CreateAdminMember,
+    SetMemberAdmin { relatiecode: String },
+}
+
+pub async fn parse(pool: PgPool) {
+    let cli = Cli::parse();
+
+    match &cli.command {
+        Some(Commands::Serve) => {
+            crate::util::serve::serve(pool).await;
+        }
+        Some(Commands::CreateAdminMember) => {
+            create_admin_member(&pool).await.unwrap();
+        }
+        Some(Commands::SetMemberAdmin {
+            relatiecode: member_id,
+        }) => {
+            set_member_admin(&pool, member_id).await.unwrap();
+        }
+        None => {}
+    }
+}
+
+pub async fn create_admin_member(pool: &PgPool) -> Result<(), sqlx::Error> {
+    use crate::database::model::Member as DbMember;
+
+    let member = DbMember {
+        member_id: "D000000".to_string(),
+        first_name: "Admin".to_string(),
+        full_name: "Admin Admin".to_string(),
+        registration_token: None,
+        diploma: None,
+        groups: Groups::empty(),
+        roles: Roles::ADMIN,
+    };
+
+    let mut transaction = pool.begin().await?;
+
+    DbMember::insert_many(&mut transaction, vec![member]).await?;
+
+    transaction.commit().await?;
+
+    Ok(())
+}
+
+pub async fn set_member_admin(pool: &PgPool, id: &str) -> Result<(), sqlx::Error> {
+    sqlx::query!(
+        "
+            UPDATE ONLY members SET roles = $1 WHERE member_id = $2
+        ",
+        Roles::ADMIN.bits() as i64,
+        id
+    )
+    .execute(pool)
+    .await?;
+
+    Ok(())
+}

server/src/util/error.rs

@@ -0,0 +1,82 @@
+use axum::{
+    http::StatusCode,
+    response::{IntoResponse, Response},
+    Json,
+};
+
+#[derive(thiserror::Error, Debug)]
+pub enum Error {
+    #[error(transparent)]
+    Csv(#[from] csv::Error),
+
+    #[error(transparent)]
+    Auth(#[from] crate::auth::AuthError),
+
+    #[error(transparent)]
+    Sqlx(#[from] sqlx::Error),
+
+    #[error("resource not found")]
+    NotFound,
+
+    #[error("Invalid request, expected {expected:?}")]
+    BadRequest { expected: String },
+}
+
+#[derive(serde::Serialize)]
+struct ErrorResponse {
+    code: &'static str,
+    description: String,
+}
+
+impl ErrorResponse {
+    fn new(code: &'static str, description: String) -> Self {
+        Self { code, description }
+    }
+}
+
+impl IntoResponse for Error {
+    fn into_response(self) -> Response {
+        let (status_code, code) = match self {
+            Self::Sqlx(ref err_kind) => match err_kind {
+                sqlx::Error::RowNotFound => (StatusCode::NOT_FOUND, "DATABASE_ROW_NOT_FOUND"),
+                sqlx::Error::Database(db_err) => match db_err.kind() {
+                    sqlx::error::ErrorKind::UniqueViolation => {
+                        (StatusCode::INTERNAL_SERVER_ERROR, "DATABASE_DUPLICATE")
+                    }
+                    _ => (StatusCode::INTERNAL_SERVER_ERROR, "DATABASE_ERROR"),
+                },
+                _ => (StatusCode::INTERNAL_SERVER_ERROR, "DATABASE_ERROR"),
+            },
+
+            Self::Csv(ref err_kind) => match err_kind.kind() {
+                csv::ErrorKind::UnequalLengths { .. } => {
+                    (StatusCode::BAD_REQUEST, "CSV_INPUT_INVALID")
+                }
+                _ => (StatusCode::INTERNAL_SERVER_ERROR, "CSV_ERROR"),
+            },
+
+            Self::Auth(ref err_kind) => match err_kind {
+                crate::auth::AuthError::NoPermssions => {
+                    (StatusCode::FORBIDDEN, "AUTH_NO_PERMISSIONS")
+                }
+                crate::auth::AuthError::Unauthorized => {
+                    (StatusCode::UNAUTHORIZED, "AUTH_UNAUTHORIZED")
+                }
+                crate::auth::AuthError::InvalidToken => {
+                    (StatusCode::BAD_REQUEST, "AUTH_INVALID_TOKEN")
+                }
+                crate::auth::AuthError::InvalidPassword => {
+                    (StatusCode::BAD_REQUEST, "AUTH_INVALID_PASSWORD")
+                }
+                _ => (StatusCode::INTERNAL_SERVER_ERROR, "AUTH_ERROR"),
+            },
+
+            Self::BadRequest { .. } => (StatusCode::BAD_REQUEST, "INVALID_BODY"),
+            Self::NotFound => (StatusCode::NOT_FOUND, "NOT_FOUND"),
+        };
+
+        let body = ErrorResponse::new(code, self.to_string());
+
+        (status_code, Json(body)).into_response()
+    }
+}

server/src/util/helpers.rs

@@ -0,0 +1,6 @@
+pub fn convert_vec<T, U>(vec: Vec<T>) -> Vec<U>
+where
+    U: From<T>,
+{
+    vec.into_iter().map(U::from).collect()
+}

server/src/util/serve.rs

@@ -0,0 +1,31 @@
+use std::sync::Arc;
+
+use axum::Router;
+use sqlx::PgPool;
+use tokio::{net::TcpListener, sync::Mutex};
+
+use crate::routes::member::migrate::MigrationStore;
+use crate::routes::routes;
+use crate::AppState;
+
+pub async fn serve(pool: PgPool) {
+    let migration_store = Arc::new(Mutex::new(MigrationStore::default()));
+
+    let app_state = AppState {
+        pool,
+        migration_store,
+    };
+
+    // Serve app
+    let app = Router::new().nest("/v1", routes()).with_state(app_state);
+
+    let listener = TcpListener::bind("127.0.0.1:3000")
+        .await
+        .expect("Error while initializing listener");
+
+    tracing::info!("Listening on {}", listener.local_addr().unwrap());
+
+    axum::serve(listener, app)
+        .await
+        .expect("Error while serving axum application");
+}