fix: use correct env var in dockerfile/compose

.woodpecker/build-and-publish.yml

@@ -3,21 +3,6 @@ when:
     branch: main
 
 steps:
-  - name: build-x86_64
-    image: rust:bookworm
-    commands:
-      - cargo build --release
-  - name: build-arm64
-    image: rust:bookworm
-    commands:
-      - dpkg --add-architecture arm64
-      - apt-get update -y && apt-get install -y crossbuild-essential-arm64 libssl-dev:arm64
-      - rustup target add aarch64-unknown-linux-gnu
-      - cargo build --target aarch64-unknown-linux-gnu --release
-    environment:
-      CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER: aarch64-linux-gnu-gcc
-      PKG_CONFIG_ALLOW_CROSS: 1
-      PKG_CONFIG_PATH: /usr/aarch64-linux-gnu/lib/pkgconfig
   - name: container-build-and-publish
     image: docker
     commands:

.woodpecker/publish-docs.yml

@@ -1,19 +0,0 @@
-when:
-  - event: push
-    branch: main
-
-steps:
-  - name: build-docs
-    image: rust:bookworm
-    commands:
-      - cargo doc --release --no-deps
-
-  - name: publish-docs
-    image: debian:12
-    commands:
-      - apt update -y && apt install -y rsync openssh-client
-      - printf "Host *\n  StrictHostKeyChecking no" >> /etc/ssh/ssh_config
-      - ssh-agent bash -c "ssh-add <(echo '$KEY' | base64 -d) && rsync --archive --verbose --compress --hard-links --delete-during --partial --progress ./target/doc/ root@gorb.app:/var/www/docs.gorb.app/api && ssh root@gorb.app systemctl reload caddy.service"
-    environment:
-      KEY:
-        from_secret: ssh_key

Cargo.toml

@@ -8,12 +8,6 @@ strip = true
 lto = true
 codegen-units = 1
 
-# Speed up compilation to make dev bearable
-[profile.dev]
-debug = 0
-strip = "debuginfo"
-codegen-units = 512
-
 [dependencies]
 actix-cors = "0.7.1"
 actix-web = "4.11"
@@ -27,25 +21,24 @@ regex = "1.11"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 simple_logger = "5.0.0"
-redis = { version = "0.32", features= ["tokio-comp"] }
+redis = { version = "0.31.0", features= ["tokio-comp"] }
-tokio-tungstenite = { version = "0.27", features = ["native-tls", "url"] }
+tokio-tungstenite = { version = "0.26", features = ["native-tls", "url"] }
 toml = "0.8"
 url = { version = "2.5", features = ["serde"] }
-uuid = { version = "1.17", features = ["serde", "v7"] }
+uuid = { version = "1.16", features = ["serde", "v7"] }
 random-string = "1.1"
 actix-ws = "0.3.0"
 futures-util = "0.3.31"
-bunny-api-tokio = { version = "0.4", features = ["edge_storage"], default-features = false }
+bunny-api-tokio = "0.3.0"
 bindet = "0.3.2"
 deadpool = "0.12"
-diesel = { version = "2.2", features = ["uuid", "chrono"], default-features = false }
+diesel = { version = "2.2", features = ["uuid"] }
 diesel-async = { version = "0.5", features = ["deadpool", "postgres", "async-connection-wrapper"] }
 diesel_migrations = { version = "2.2.0", features = ["postgres"] }
 thiserror = "2.0.12"
 actix-multipart = "0.7.2"
-lettre = { version = "0.11", features = ["tokio1", "tokio1-native-tls"] }
+actix-files = "0.6.6"
-chrono = { version = "0.4.41", features = ["serde"] }
 
 [dependencies.tokio]
-version = "1.45"
+version = "1.44"
 features = ["full"]

Dockerfile

@@ -1,17 +1,16 @@
-FROM --platform=linux/amd64 debian:12-slim AS prep
+FROM rust:bookworm AS builder
 
 WORKDIR /src
 
-COPY target/release/backend backend-amd64
+COPY . .
-COPY target/aarch64-unknown-linux-gnu/release/backend backend-arm64
+
+RUN cargo build --release
 
 FROM debian:12-slim
 
-ARG TARGETARCH
+RUN apt update && apt install libssl3 && rm -rf /var/lib/apt/lists/* /var/cache/apt/* /tmp/*
 
-RUN apt update -y && apt install libssl3 ca-certificates -y && rm -rf /var/lib/apt/lists/* /var/cache/apt/* /tmp/*
+COPY --from=builder /src/target/release/backend /usr/bin/gorb-backend
-
-COPY --from=prep /src/backend-${TARGETARCH} /usr/bin/gorb-backend
 
 COPY entrypoint.sh /usr/bin/entrypoint.sh
 
@@ -19,8 +18,7 @@ RUN useradd --create-home --home-dir /gorb gorb
 
 USER gorb
 
-ENV WEB_FRONTEND_URL=https://gorb.app/web/ \
+ENV WEB_URL=http://localhost:8080 \
-WEB_BASE_PATH=/api \
 DATABASE_USERNAME=gorb \
 DATABASE_PASSWORD=gorb \
 DATABASE=gorb \
@@ -28,14 +26,9 @@ DATABASE_HOST=database \
 DATABASE_PORT=5432 \
 CACHE_DB_HOST=valkey \
 CACHE_DB_PORT=6379 \
-BUNNY_API_KEY=your_storage_zone_password_here \
+BUNNY_API_KEY= \
-BUNNY_ENDPOINT=Frankfurt \
+BUNNY_ENDPOINT= \
-BUNNY_ZONE=gorb \
+BUNNY_ZONE= \
-BUNNY_CDN_URL=https://cdn.gorb.app \
+BUNNY_CDN_URL=
-MAIL_ADDRESS=noreply@gorb.app \
-MAIL_TLS=tls \
-SMTP_SERVER=mail.gorb.app \
-SMTP_USERNAME=your_smtp_username \
-SMTP_PASSWORD=your_smtp_password
 
 ENTRYPOINT ["/usr/bin/entrypoint.sh"]

build.rs

@@ -1,16 +1,3 @@
-use std::process::Command;
-
 fn main() {
     println!("cargo:rerun-if-changed=migrations");
-
-    let git_short_hash = Command::new("git")
-        .args(["rev-parse", "--short", "HEAD"])
-        .output()
-        .ok()
-        .and_then(|o| String::from_utf8(o.stdout).ok())
-        .map(|s| s.trim().to_string()) // Trim newline
-        .unwrap_or_else(|| "UNKNOWN".to_string());
-
-    // Tell Cargo to set `GIT_SHORT_HASH` for the main compilation
-    println!("cargo:rustc-env=GIT_SHORT_HASH={}", git_short_hash);
 }

compose.dev.yml

@@ -18,21 +18,18 @@ services:
       - gorb-backend:/gorb
     environment:
       #- RUST_LOG=debug
-      - WEB_FRONTEND_URL=https://gorb.app/web/
+      # This should be changed to the public URL of the server!
+      - WEB_URL=http://localhost:8080
       - DATABASE_USERNAME=gorb
       - DATABASE_PASSWORD=gorb
       - DATABASE=gorb
       - DATABASE_HOST=database
       - DATABASE_PORT=5432
-      - BUNNY_API_KEY=your_storage_zone_password_here
+      # These can be set to use a CDN, if they are not set then files will be stored locally
-      - BUNNY_ENDPOINT=Frankfurt
+      #- BUNNY_API_KEY=your_storage_zone_password_here
-      - BUNNY_ZONE=gorb
+      #- BUNNY_ENDPOINT=Frankfurt
-      - BUNNY_CDN_URL=https://cdn.gorb.app
+      #- BUNNY_ZONE=gorb
-      - MAIL_ADDRESS=Gorb <noreply@gorb.app>
+      #- BUNNY_CDN_URL=https://cdn.gorb.app
-      - MAIL_TLS=tls
-      - SMTP_SERVER=mail.gorb.app
-      - SMTP_USERNAME=your_smtp_username
-      - SMTP_PASSWORD=your_smtp_password
   database:
     image: postgres:16
     restart: always

compose.yml

@@ -16,21 +16,18 @@ services:
       - gorb-backend:/gorb
     environment:
       #- RUST_LOG=debug
-      - WEB_FRONTEND_URL=https://gorb.app/web/
+      # This should be changed to the public URL of the server!
+      - WEB_URL=http://localhost:8080
       - DATABASE_USERNAME=gorb
       - DATABASE_PASSWORD=gorb
       - DATABASE=gorb
       - DATABASE_HOST=database
       - DATABASE_PORT=5432
-      - BUNNY_API_KEY=your_storage_zone_password_here
+      # These can be set to use a CDN, if they are not set then files will be stored locally
-      - BUNNY_ENDPOINT=Frankfurt
+      #- BUNNY_API_KEY=your_storage_zone_password_here
-      - BUNNY_ZONE=gorb
+      #- BUNNY_ENDPOINT=Frankfurt
-      - BUNNY_CDN_URL=https://cdn.gorb.app
+      #- BUNNY_ZONE=gorb
-      - MAIL_ADDRESS=Gorb <noreply@gorb.app>
+      #- BUNNY_CDN_URL=https://cdn.gorb.app
-      - MAIL_TLS=tls
-      - SMTP_SERVER=mail.gorb.app
-      - SMTP_USERNAME=your_smtp_username
-      - SMTP_PASSWORD=your_smtp_password
   database:
     image: postgres:16
     restart: always

entrypoint.sh

@@ -8,11 +8,14 @@ if [ ! -d "/gorb/logs" ]; then
     mkdir /gorb/logs
 fi
 
+if [ ! -d "/gorb/data" ]; then
+    mkdir /gorb/data
+fi
+
 if [ ! -f "/gorb/config/config.toml" ]; then
 cat > /gorb/config/config.toml <<EOF
 [web]
-frontend_url = "${WEB_FRONTEND_URL}"
+url = "${WEB_URL}"
-base_path = "${WEB_BASE_PATH}"
 
 [database]
 username = "${DATABASE_USERNAME}"
@@ -25,21 +28,17 @@ port = ${DATABASE_PORT}
 host = "${CACHE_DB_HOST}"
 port = ${CACHE_DB_PORT}
 
+EOF
+fi
+
+if [ -n "${BUNNY_API_KEY}" ] && ! grep -q "^\[bunny\]" "/gorb/config/config.toml"; then
+    cat >> "/gorb/config/config.toml" <<EOF
 [bunny]
 api_key = "${BUNNY_API_KEY}"
 endpoint = "${BUNNY_ENDPOINT}"
 storage_zone = "${BUNNY_ZONE}"
 cdn_url = "${BUNNY_CDN_URL}"
 
-[mail]
-address = "${MAIL_ADDRESS}"
-tls = "${MAIL_TLS}"
-
-[mail.smtp]
-server = "${SMTP_SERVER}"
-username = "${SMTP_USERNAME}"
-password = "${SMTP_PASSWORD}"
-
 EOF
 fi
 
@@ -65,4 +64,4 @@ rotate_log "/gorb/logs/backend.log"
 # Give the DB time to start up before connecting
 sleep 5
 
-/usr/bin/gorb-backend --config /gorb/config/config.toml 2>&1 | tee /gorb/logs/backend.log
+/usr/bin/gorb-backend --config /gorb/config/config.toml --data-dir /gorb/data 2>&1 | tee /gorb/logs/backend.log

migrations/2025-05-26-181536_add_channel_ordering/down.sql

@@ -1,2 +0,0 @@
--- This file should undo anything in `up.sql`
-ALTER TABLE channels DROP COLUMN is_above;

migrations/2025-05-26-181536_add_channel_ordering/up.sql

@@ -1,2 +0,0 @@
--- Your SQL goes here
-ALTER TABLE channels ADD COLUMN is_above UUID UNIQUE REFERENCES channels(uuid) DEFAULT NULL;

migrations/2025-05-27-105059_redo_role_ordering/down.sql

@@ -1,3 +0,0 @@
--- This file should undo anything in `up.sql`
-ALTER TABLE roles ADD COLUMN position int NOT NULL DEFAULT 0;
-ALTER TABLE roles DROP COLUMN is_above;

migrations/2025-05-27-105059_redo_role_ordering/up.sql

@@ -1,3 +0,0 @@
--- Your SQL goes here
-ALTER TABLE roles DROP COLUMN position;
-ALTER TABLE roles ADD COLUMN is_above UUID UNIQUE REFERENCES roles(uuid) DEFAULT NULL;

migrations/2025-05-27-162114_create_email_tokens/down.sql

@@ -1,2 +0,0 @@
--- This file should undo anything in `up.sql`
-DROP TABLE email_tokens;

migrations/2025-05-27-162114_create_email_tokens/up.sql

@@ -1,7 +0,0 @@
--- Your SQL goes here
-CREATE TABLE email_tokens (
-    token VARCHAR(64) NOT NULL,
-    user_uuid uuid UNIQUE NOT NULL REFERENCES users(uuid),
-    created_at TIMESTAMPTZ NOT NULL,
-    PRIMARY KEY (token, user_uuid)
-);

migrations/2025-05-28-175918_create_password_reset_tokens/down.sql

@@ -1,2 +0,0 @@
--- This file should undo anything in `up.sql`
-DROP TABLE password_reset_tokens;

migrations/2025-05-28-175918_create_password_reset_tokens/up.sql

@@ -1,7 +0,0 @@
--- Your SQL goes here
-CREATE TABLE password_reset_tokens (
-    token VARCHAR(64) NOT NULL,
-    user_uuid uuid UNIQUE NOT NULL REFERENCES users(uuid),
-    created_at TIMESTAMPTZ NOT NULL,
-    PRIMARY KEY (token, user_uuid)
-);

migrations/2025-06-01-134036_add_pronouns_to_users/down.sql

@@ -1,2 +0,0 @@
--- This file should undo anything in `up.sql`
-ALTER TABLE users DROP COLUMN pronouns;

migrations/2025-06-01-134036_add_pronouns_to_users/up.sql

@@ -1,2 +0,0 @@
--- Your SQL goes here
-ALTER TABLE users ADD COLUMN pronouns VARCHAR(32) DEFAULT NULL;

migrations/2025-06-01-143713_add_about_to_users/down.sql

@@ -1,2 +0,0 @@
--- This file should undo anything in `up.sql`
-ALTER TABLE users DROP COLUMN about;

migrations/2025-06-01-143713_add_about_to_users/up.sql

@@ -1,2 +0,0 @@
--- Your SQL goes here
-ALTER TABLE users ADD COLUMN about VARCHAR(200) DEFAULT NULL;

migrations/2025-06-03-103311_remove_email_tokens/down.sql

@@ -1,7 +0,0 @@
--- This file should undo anything in `up.sql`
-CREATE TABLE email_tokens (
-    token VARCHAR(64) NOT NULL,
-    user_uuid uuid UNIQUE NOT NULL REFERENCES users(uuid),
-    created_at TIMESTAMPTZ NOT NULL,
-    PRIMARY KEY (token, user_uuid)
-);

migrations/2025-06-03-103311_remove_email_tokens/up.sql

@@ -1,2 +0,0 @@
--- Your SQL goes here
-DROP TABLE email_tokens;

migrations/2025-06-03-110142_remove_password_reset_tokens/down.sql

@@ -1,7 +0,0 @@
--- This file should undo anything in `up.sql`
-CREATE TABLE password_reset_tokens (
-    token VARCHAR(64) NOT NULL,
-    user_uuid uuid UNIQUE NOT NULL REFERENCES users(uuid),
-    created_at TIMESTAMPTZ NOT NULL,
-    PRIMARY KEY (token, user_uuid)
-);

migrations/2025-06-03-110142_remove_password_reset_tokens/up.sql

@@ -1,2 +0,0 @@
--- Your SQL goes here
-DROP TABLE password_reset_tokens;

migrations/2025-06-06-145916_guild_ownership_changes/down.sql

@@ -1,14 +0,0 @@
--- This file should undo anything in `up.sql`
-ALTER TABLE guilds
-ADD COLUMN owner_uuid UUID REFERENCES users(uuid);
-
-UPDATE guilds g
-SET owner_uuid = gm.user_uuid
-FROM guild_members gm
-WHERE gm.guild_uuid = g.uuid AND gm.is_owner = TRUE;
-
-ALTER TABLE guilds
-ALTER COLUMN owner_uuid SET NOT NULL;
-
-ALTER TABLE guild_members
-DROP COLUMN is_owner;

migrations/2025-06-06-145916_guild_ownership_changes/up.sql

@@ -1,14 +0,0 @@
--- Your SQL goes here
-ALTER TABLE guild_members
-ADD COLUMN is_owner BOOLEAN NOT NULL DEFAULT false;
-
-UPDATE guild_members gm
-SET is_owner = true
-FROM guilds g
-WHERE gm.guild_uuid = g.uuid AND gm.user_uuid = g.owner_uuid;
-
-CREATE UNIQUE INDEX one_owner_per_guild ON guild_members (guild_uuid)
-WHERE is_owner;
-
-ALTER TABLE guilds
-DROP COLUMN owner_uuid;

src/api/mod.rs

@@ -1,13 +1,9 @@
-//! `/api` Contains the entire API
-
 use actix_web::Scope;
 use actix_web::web;
 
 mod v1;
 mod versions;
 
-pub fn web(path: &str) -> Scope {
+pub fn web() -> Scope {
-    web::scope(path.trim_end_matches('/'))
+    web::scope("/api").service(v1::web()).service(versions::res)
-        .service(v1::web())
-        .service(versions::get)
 }

src/api/v1/auth/login.rs

@@ -5,15 +5,14 @@ use argon2::{PasswordHash, PasswordVerifier};
 use diesel::{ExpressionMethods, QueryDsl, dsl::insert_into};
 use diesel_async::RunQueryDsl;
 use serde::Deserialize;
+use uuid::Uuid;
 
 use crate::{
     Data,
+    api::v1::auth::{EMAIL_REGEX, PASSWORD_REGEX, USERNAME_REGEX},
     error::Error,
     schema::*,
-    utils::{
+    utils::{generate_access_token, generate_refresh_token, refresh_token_cookie},
-        PASSWORD_REGEX, generate_token, new_refresh_token_cookie,
-        user_uuid_from_identifier,
-    },
 };
 
 use super::Response;
@@ -38,20 +37,58 @@ pub async fn response(
 
     let mut conn = data.pool.get().await?;
 
-    let uuid = user_uuid_from_identifier(&mut conn, &login_information.username).await?;
+    if EMAIL_REGEX.is_match(&login_information.username) {
-
+        // FIXME: error handling, right now i just want this to work
-    let database_password: String = dsl::users
+        let (uuid, password): (Uuid, String) = dsl::users
-        .filter(dsl::uuid.eq(uuid))
+            .filter(dsl::email.eq(&login_information.username))
-        .select(dsl::password)
+            .select((dsl::uuid, dsl::password))
             .get_result(&mut conn)
             .await?;
 
+        return login(
+            data.clone(),
+            uuid,
+            login_information.password.clone(),
+            password,
+            login_information.device_name.clone(),
+        )
+        .await;
+    } else if USERNAME_REGEX.is_match(&login_information.username) {
+        // FIXME: error handling, right now i just want this to work
+        let (uuid, password): (Uuid, String) = dsl::users
+            .filter(dsl::username.eq(&login_information.username))
+            .select((dsl::uuid, dsl::password))
+            .get_result(&mut conn)
+            .await?;
+
+        return login(
+            data.clone(),
+            uuid,
+            login_information.password.clone(),
+            password,
+            login_information.device_name.clone(),
+        )
+        .await;
+    }
+
+    Ok(HttpResponse::Unauthorized().finish())
+}
+
+async fn login(
+    data: actix_web::web::Data<Data>,
+    uuid: Uuid,
+    request_password: String,
+    database_password: String,
+    device_name: String,
+) -> Result<HttpResponse, Error> {
+    let mut conn = data.pool.get().await?;
+
     let parsed_hash = PasswordHash::new(&database_password)
         .map_err(|e| Error::PasswordHashError(e.to_string()))?;
 
     if data
         .argon2
-        .verify_password(login_information.password.as_bytes(), &parsed_hash)
+        .verify_password(request_password.as_bytes(), &parsed_hash)
         .is_err()
     {
         return Err(Error::Unauthorized(
@@ -59,8 +96,8 @@ pub async fn response(
         ));
     }
 
-    let refresh_token = generate_token::<32>()?;
+    let refresh_token = generate_refresh_token()?;
-    let access_token = generate_token::<16>()?;
+    let access_token = generate_access_token()?;
 
     let current_time = SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs() as i64;
 
@@ -71,7 +108,7 @@ pub async fn response(
             rdsl::token.eq(&refresh_token),
             rdsl::uuid.eq(uuid),
             rdsl::created_at.eq(current_time),
-            rdsl::device_name.eq(&login_information.device_name),
+            rdsl::device_name.eq(device_name),
         ))
         .execute(&mut conn)
         .await?;
@@ -89,6 +126,6 @@ pub async fn response(
         .await?;
 
     Ok(HttpResponse::Ok()
-        .cookie(new_refresh_token_cookie(&data.config, refresh_token))
+        .cookie(refresh_token_cookie(refresh_token))
         .json(Response { access_token }))
 }

src/api/v1/auth/logout.rs

@@ -1,38 +0,0 @@
-use actix_web::{HttpRequest, HttpResponse, post, web};
-use diesel::{ExpressionMethods, delete};
-use diesel_async::RunQueryDsl;
-
-use crate::{
-    Data,
-    error::Error,
-    schema::refresh_tokens::{self, dsl},
-};
-
-/// `GET /api/v1/logout`
-///
-/// requires auth: kinda, needs refresh token set but no access token is technically required
-///
-/// ### Responses
-/// 200 Logged out
-/// 404 Refresh token is invalid
-/// 401 Unauthorized (no refresh token found)
-///
-#[post("/logout")]
-pub async fn res(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse, Error> {
-    let mut refresh_token_cookie = req.cookie("refresh_token").ok_or(Error::Unauthorized(
-        "request has no refresh token".to_string(),
-    ))?;
-
-    let refresh_token = String::from(refresh_token_cookie.value());
-
-    let mut conn = data.pool.get().await?;
-
-    delete(refresh_tokens::table)
-        .filter(dsl::token.eq(refresh_token))
-        .execute(&mut conn)
-        .await?;
-
-    refresh_token_cookie.make_removal();
-
-    Ok(HttpResponse::Ok().cookie(refresh_token_cookie).finish())
-}

src/api/v1/auth/mod.rs

@@ -1,37 +1,42 @@
-use std::time::{SystemTime, UNIX_EPOCH};
+use std::{
+    sync::LazyLock,
+    time::{SystemTime, UNIX_EPOCH},
+};
 
 use actix_web::{Scope, web};
 use diesel::{ExpressionMethods, QueryDsl};
 use diesel_async::RunQueryDsl;
+use regex::Regex;
 use serde::Serialize;
 use uuid::Uuid;
 
 use crate::{Conn, error::Error, schema::access_tokens::dsl};
 
 mod login;
-mod logout;
 mod refresh;
 mod register;
-mod reset_password;
 mod revoke;
-mod verify_email;
 
 #[derive(Serialize)]
 struct Response {
     access_token: String,
 }
 
+static EMAIL_REGEX: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(r"[-A-Za-z0-9!#$%&'*+/=?^_`{|}~]+(?:\.[-A-Za-z0-9!#$%&'*+/=?^_`{|}~]+)*@(?:[A-Za-z0-9](?:[-A-Za-z0-9]*[A-Za-z0-9])?\.)+[A-Za-z0-9](?:[-A-Za-z0-9]*[A-Za-z0-9])?").unwrap()
+});
+
+static USERNAME_REGEX: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"^[a-z0-9_.-]+$").unwrap());
+
+// Password is expected to be hashed using SHA3-384
+static PASSWORD_REGEX: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"[0-9a-f]{96}").unwrap());
+
 pub fn web() -> Scope {
     web::scope("/auth")
         .service(register::res)
         .service(login::response)
-        .service(logout::res)
         .service(refresh::res)
         .service(revoke::res)
-        .service(verify_email::get)
-        .service(verify_email::post)
-        .service(reset_password::get)
-        .service(reset_password::post)
 }
 
 pub async fn check_access_token(access_token: &str, conn: &mut Conn) -> Result<Uuid, Error> {

src/api/v1/auth/refresh.rs

@@ -11,18 +11,20 @@ use crate::{
         access_tokens::{self, dsl},
         refresh_tokens::{self, dsl as rdsl},
     },
-    utils::{generate_token, new_refresh_token_cookie},
+    utils::{generate_access_token, generate_refresh_token, refresh_token_cookie},
 };
 
 use super::Response;
 
 #[post("/refresh")]
 pub async fn res(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse, Error> {
-    let mut refresh_token_cookie = req.cookie("refresh_token").ok_or(Error::Unauthorized(
+    let recv_refresh_token_cookie = req.cookie("refresh_token");
-        "request has no refresh token".to_string(),
-    ))?;
 
-    let mut refresh_token = String::from(refresh_token_cookie.value());
+    if recv_refresh_token_cookie.is_none() {
+        return Ok(HttpResponse::Unauthorized().finish());
+    }
+
+    let mut refresh_token = String::from(recv_refresh_token_cookie.unwrap().value());
 
     let current_time = SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs() as i64;
 
@@ -45,6 +47,8 @@ pub async fn res(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse
                 error!("{}", error);
             }
 
+            let mut refresh_token_cookie = refresh_token_cookie(refresh_token);
+
             refresh_token_cookie.make_removal();
 
             return Ok(HttpResponse::Unauthorized()
@@ -55,7 +59,14 @@ pub async fn res(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse
         let current_time = SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs() as i64;
 
         if lifetime > 1987200 {
-            let new_refresh_token = generate_token::<32>()?;
+            let new_refresh_token = generate_refresh_token();
+
+            if new_refresh_token.is_err() {
+                error!("{}", new_refresh_token.unwrap_err());
+                return Ok(HttpResponse::InternalServerError().finish());
+            }
+
+            let new_refresh_token = new_refresh_token.unwrap();
 
             match update(refresh_tokens::table)
                 .filter(rdsl::token.eq(&refresh_token))
@@ -75,7 +86,7 @@ pub async fn res(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse
             }
         }
 
-        let access_token = generate_token::<16>()?;
+        let access_token = generate_access_token()?;
 
         update(access_tokens::table)
             .filter(dsl::refresh_token.eq(&refresh_token))
@@ -87,10 +98,12 @@ pub async fn res(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse
             .await?;
 
         return Ok(HttpResponse::Ok()
-            .cookie(new_refresh_token_cookie(&data.config, refresh_token))
+            .cookie(refresh_token_cookie(refresh_token))
             .json(Response { access_token }));
     }
 
+    let mut refresh_token_cookie = refresh_token_cookie(refresh_token);
+
     refresh_token_cookie.make_removal();
 
     Ok(HttpResponse::Unauthorized()

src/api/v1/auth/register.rs

@@ -13,16 +13,14 @@ use uuid::Uuid;
 use super::Response;
 use crate::{
     Data,
+    api::v1::auth::{EMAIL_REGEX, PASSWORD_REGEX, USERNAME_REGEX},
     error::Error,
     schema::{
         access_tokens::{self, dsl as adsl},
         refresh_tokens::{self, dsl as rdsl},
         users::{self, dsl as udsl},
     },
-    utils::{
+    utils::{generate_access_token, generate_refresh_token, refresh_token_cookie},
-        EMAIL_REGEX, PASSWORD_REGEX, USERNAME_REGEX, generate_token,
-        new_refresh_token_cookie,
-    },
 };
 
 #[derive(Deserialize)]
@@ -69,12 +67,6 @@ pub async fn res(
     account_information: web::Json<AccountInformation>,
     data: web::Data<Data>,
 ) -> Result<HttpResponse, Error> {
-    if !data.config.instance.registration {
-        return Err(Error::Forbidden(
-            "registration is disabled on this instance".to_string(),
-        ));
-    }
-
     let uuid = Uuid::now_v7();
 
     if !EMAIL_REGEX.is_match(&account_information.email) {
@@ -120,8 +112,8 @@ pub async fn res(
             .execute(&mut conn)
             .await?;
 
-        let refresh_token = generate_token::<32>()?;
+        let refresh_token = generate_refresh_token()?;
-        let access_token = generate_token::<16>()?;
+        let access_token = generate_access_token()?;
 
         let current_time = SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs() as i64;
 
@@ -146,7 +138,7 @@ pub async fn res(
             .await?;
 
         return Ok(HttpResponse::Ok()
-            .cookie(new_refresh_token_cookie(&data.config, refresh_token))
+            .cookie(refresh_token_cookie(refresh_token))
             .json(Response { access_token }));
     }
 

src/api/v1/auth/reset_password.rs

@@ -1,83 +0,0 @@
-//! `/api/v1/auth/reset-password` Endpoints for resetting user password
-
-use actix_web::{HttpResponse, get, post, web};
-use chrono::{Duration, Utc};
-use serde::Deserialize;
-
-use crate::{Data, error::Error, objects::PasswordResetToken};
-
-#[derive(Deserialize)]
-struct Query {
-    identifier: String,
-}
-
-/// `GET /api/v1/auth/reset-password` Sends password reset email to user
-///
-/// requires auth? no
-///
-/// ### Query Parameters
-/// identifier: Email or username
-///
-/// ### Responses
-/// 200 Email sent
-/// 429 Too Many Requests
-/// 404 Not found
-/// 400 Bad request
-///
-#[get("/reset-password")]
-pub async fn get(query: web::Query<Query>, data: web::Data<Data>) -> Result<HttpResponse, Error> {
-    if let Ok(password_reset_token) =
-        PasswordResetToken::get_with_identifier(&data, query.identifier.clone()).await
-    {
-        if Utc::now().signed_duration_since(password_reset_token.created_at) > Duration::hours(1) {
-            password_reset_token.delete(&data).await?;
-        } else {
-            return Err(Error::TooManyRequests(
-                "Please allow 1 hour before sending a new email".to_string(),
-            ));
-        }
-    }
-
-    PasswordResetToken::new(&data, query.identifier.clone()).await?;
-
-    Ok(HttpResponse::Ok().finish())
-}
-
-#[derive(Deserialize)]
-struct ResetPassword {
-    password: String,
-    token: String,
-}
-
-/// `POST /api/v1/auth/reset-password` Resets user password
-///
-/// requires auth? no
-///
-/// ### Request Example:
-/// ```
-/// json!({
-///     "password": "1608c17a27f6ae3891c23d680c73ae91528f20a54dcf4973e2c3126b9734f48b7253047f2395b51bb8a44a6daa188003",
-///     "token": "a3f7e29c1b8d0456e2c9f83b7a1d6e4f5028c3b9a7e1f2d5c6b8a0d3e7f4a2b"
-/// });
-/// ```
-///
-/// ### Responses
-/// 200 Success
-/// 410 Token Expired
-/// 404 Not Found
-/// 400 Bad Request
-///
-#[post("/reset-password")]
-pub async fn post(
-    reset_password: web::Json<ResetPassword>,
-    data: web::Data<Data>,
-) -> Result<HttpResponse, Error> {
-    let password_reset_token =
-        PasswordResetToken::get(&data, reset_password.token.clone()).await?;
-
-    password_reset_token
-        .set_password(&data, reset_password.password.clone())
-        .await?;
-
-    Ok(HttpResponse::Ok().finish())
-}

src/api/v1/auth/verify_email.rs

@@ -1,101 +0,0 @@
-//! `/api/v1/auth/verify-email` Endpoints for verifying user emails
-
-use actix_web::{HttpRequest, HttpResponse, get, post, web};
-use chrono::{Duration, Utc};
-use serde::Deserialize;
-
-use crate::{
-    Data,
-    api::v1::auth::check_access_token,
-    error::Error,
-    objects::{EmailToken, Me},
-    utils::get_auth_header,
-};
-
-#[derive(Deserialize)]
-struct Query {
-    token: String,
-}
-
-/// `GET /api/v1/auth/verify-email` Verifies user email address
-///
-/// requires auth? yes
-///
-/// ### Query Parameters
-/// token
-///
-/// ### Responses
-/// 200 Success
-/// 410 Token Expired
-/// 404 Not Found
-/// 401 Unauthorized
-///
-#[get("/verify-email")]
-pub async fn get(
-    req: HttpRequest,
-    query: web::Query<Query>,
-    data: web::Data<Data>,
-) -> Result<HttpResponse, Error> {
-    let headers = req.headers();
-
-    let auth_header = get_auth_header(headers)?;
-
-    let mut conn = data.pool.get().await?;
-
-    let uuid = check_access_token(auth_header, &mut conn).await?;
-
-    let me = Me::get(&mut conn, uuid).await?;
-
-    let email_token = EmailToken::get(&data, me.uuid).await?;
-
-    if query.token != email_token.token {
-        return Ok(HttpResponse::Unauthorized().finish());
-    }
-
-    me.verify_email(&mut conn).await?;
-
-    email_token.delete(&data).await?;
-
-    Ok(HttpResponse::Ok().finish())
-}
-
-/// `POST /api/v1/auth/verify-email` Sends user verification email
-///
-/// requires auth? yes
-///
-/// ### Responses
-/// 200 Email sent
-/// 204 Already verified
-/// 429 Too Many Requests
-/// 401 Unauthorized
-///
-#[post("/verify-email")]
-pub async fn post(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse, Error> {
-    let headers = req.headers();
-
-    let auth_header = get_auth_header(headers)?;
-
-    let mut conn = data.pool.get().await?;
-
-    let uuid = check_access_token(auth_header, &mut conn).await?;
-
-    let me = Me::get(&mut conn, uuid).await?;
-
-    if me.email_verified {
-        return Ok(HttpResponse::NoContent().finish());
-    }
-
-    if let Ok(email_token) = EmailToken::get(&data, me.uuid).await {
-        if Utc::now().signed_duration_since(email_token.created_at) > Duration::hours(1) {
-            email_token.delete(&data).await?;
-        } else {
-            return Err(Error::TooManyRequests(
-                "Please allow 1 hour before sending a new email".to_string(),
-            ));
-        }
-    }
-
-    EmailToken::new(&data, me).await?;
-
-    Ok(HttpResponse::Ok().finish())
-}

src/api/v1/channels/mod.rs

@@ -1,12 +0,0 @@
-use actix_web::{Scope, web};
-
-mod uuid;
-
-pub fn web() -> Scope {
-    web::scope("/channels")
-        .service(uuid::get)
-        .service(uuid::delete)
-        .service(uuid::patch)
-        .service(uuid::messages::get)
-        .service(uuid::socket::ws)
-}

src/api/v1/channels/uuid/messages.rs

@@ -1,78 +0,0 @@
-//! `/api/v1/channels/{uuid}/messages` Endpoints related to channel messages
-
-use crate::{
-    Data,
-    api::v1::auth::check_access_token,
-    error::Error,
-    objects::{Channel, Member},
-    utils::{get_auth_header, global_checks},
-};
-use ::uuid::Uuid;
-use actix_web::{HttpRequest, HttpResponse, get, web};
-use serde::Deserialize;
-
-#[derive(Deserialize)]
-struct MessageRequest {
-    amount: i64,
-    offset: i64,
-}
-
-/// `GET /api/v1/channels/{uuid}/messages` Returns user with the given UUID
-///
-/// requires auth: yes
-///
-/// requires relation: yes
-///
-/// ### Request Example
-/// ```
-/// json!({
-///     "amount": 100,
-///     "offset": 0
-/// })
-/// ```
-///
-/// ### Response Example
-/// ```
-/// json!({
-///     "uuid": "01971976-8618-74c0-b040-7ffbc44823f6",
-///     "channel_uuid": "0196fcb1-e886-7de3-b685-0ee46def9a7b",
-///     "user_uuid": "0196fc96-a822-76b0-b9bf-a9de232f54b7",
-///     "message": "test",
-///     "user": {
-///         "uuid": "0196fc96-a822-76b0-b9bf-a9de232f54b7",
-///         "username": "1234",
-///         "display_name": null,
-///         "avatar": "https://cdn.gorb.app/avatar/0196fc96-a822-76b0-b9bf-a9de232f54b7/avatar.jpg"
-///     }
-/// });
-/// ```
-///
-#[get("/{uuid}/messages")]
-pub async fn get(
-    req: HttpRequest,
-    path: web::Path<(Uuid,)>,
-    message_request: web::Query<MessageRequest>,
-    data: web::Data<Data>,
-) -> Result<HttpResponse, Error> {
-    let headers = req.headers();
-
-    let auth_header = get_auth_header(headers)?;
-
-    let channel_uuid = path.into_inner().0;
-
-    let mut conn = data.pool.get().await?;
-
-    let uuid = check_access_token(auth_header, &mut conn).await?;
-
-    global_checks(&data, uuid).await?;
-
-    let channel = Channel::fetch_one(&data, channel_uuid).await?;
-
-    Member::check_membership(&mut conn, uuid, channel.guild_uuid).await?;
-
-    let messages = channel
-        .fetch_messages(&data, message_request.amount, message_request.offset)
-        .await?;
-
-    Ok(HttpResponse::Ok().json(messages))
-}

src/api/v1/channels/uuid/mod.rs

@@ -1,147 +0,0 @@
-//! `/api/v1/channels/{uuid}` Channel specific endpoints
-
-pub mod messages;
-pub mod socket;
-
-use crate::{
-    api::v1::auth::check_access_token, error::Error, objects::{Channel, Member, Permissions}, utils::{get_auth_header, global_checks}, Data
-};
-use actix_web::{HttpRequest, HttpResponse, delete, get, patch, web};
-use serde::Deserialize;
-use uuid::Uuid;
-
-#[get("/{uuid}")]
-pub async fn get(
-    req: HttpRequest,
-    path: web::Path<(Uuid,)>,
-    data: web::Data<Data>,
-) -> Result<HttpResponse, Error> {
-    let headers = req.headers();
-
-    let auth_header = get_auth_header(headers)?;
-
-    let channel_uuid = path.into_inner().0;
-
-    let mut conn = data.pool.get().await?;
-
-    let uuid = check_access_token(auth_header, &mut conn).await?;
-
-    global_checks(&data, uuid).await?;
-
-    let channel = Channel::fetch_one(&data, channel_uuid).await?;
-
-    Member::check_membership(&mut conn, uuid, channel.guild_uuid).await?;
-
-    Ok(HttpResponse::Ok().json(channel))
-}
-
-#[delete("/{uuid}")]
-pub async fn delete(
-    req: HttpRequest,
-    path: web::Path<(Uuid,)>,
-    data: web::Data<Data>,
-) -> Result<HttpResponse, Error> {
-    let headers = req.headers();
-
-    let auth_header = get_auth_header(headers)?;
-
-    let channel_uuid = path.into_inner().0;
-
-    let mut conn = data.pool.get().await?;
-
-    let uuid = check_access_token(auth_header, &mut conn).await?;
-
-    global_checks(&data, uuid).await?;
-
-    let channel = Channel::fetch_one(&data, channel_uuid).await?;
-
-    let member = Member::check_membership(&mut conn, uuid, channel.guild_uuid).await?;
-
-    member.check_permission(&data, Permissions::DeleteChannel).await?;
-
-    channel.delete(&data).await?;
-
-    Ok(HttpResponse::Ok().finish())
-}
-
-#[derive(Deserialize)]
-struct NewInfo {
-    name: Option<String>,
-    description: Option<String>,
-    is_above: Option<String>,
-}
-
-/// `PATCH /api/v1/channels/{uuid}` Returns user with the given UUID
-///
-/// requires auth: yes
-///
-/// requires relation: yes
-///
-/// ### Request Example
-/// All fields are optional and can be nulled/dropped if only changing 1 value
-/// ```
-/// json!({
-///     "name": "gaming-chat",
-///     "description": "Gaming related topics.",
-///     "is_above": "398f6d7b-752c-4348-9771-fe6024adbfb1"
-/// });
-/// ```
-///
-/// ### Response Example
-/// ```
-/// json!({
-///     uuid: "cdcac171-5add-4f88-9559-3a247c8bba2c",
-///     guild_uuid: "383d2afa-082f-4dd3-9050-ca6ed91487b6",
-///     name: "gaming-chat",
-///     description: "Gaming related topics.",
-///     is_above: "398f6d7b-752c-4348-9771-fe6024adbfb1",
-///     permissions: {
-///         role_uuid: "79cc0806-0f37-4a06-a468-6639c4311a2d",
-///         permissions: 0
-///     }
-/// });
-/// ```
-/// NOTE: UUIDs in this response are made using `uuidgen`, UUIDs made by the actual backend will be UUIDv7 and have extractable timestamps
-#[patch("/{uuid}")]
-pub async fn patch(
-    req: HttpRequest,
-    path: web::Path<(Uuid,)>,
-    new_info: web::Json<NewInfo>,
-    data: web::Data<Data>,
-) -> Result<HttpResponse, Error> {
-    let headers = req.headers();
-
-    let auth_header = get_auth_header(headers)?;
-
-    let channel_uuid = path.into_inner().0;
-
-    let mut conn = data.pool.get().await?;
-
-    let uuid = check_access_token(auth_header, &mut conn).await?;
-
-    global_checks(&data, uuid).await?;
-
-    let mut channel = Channel::fetch_one(&data, channel_uuid).await?;
-
-    let member = Member::check_membership(&mut conn, uuid, channel.guild_uuid).await?;
-
-    member.check_permission(&data, Permissions::ManageChannel).await?;
-
-    if let Some(new_name) = &new_info.name {
-        channel.set_name(&data, new_name.to_string()).await?;
-    }
-
-    if let Some(new_description) = &new_info.description {
-        channel
-            .set_description(&data, new_description.to_string())
-            .await?;
-    }
-
-    if let Some(new_is_above) = &new_info.is_above {
-        channel
-            .set_description(&data, new_is_above.to_string())
-            .await?;
-    }
-
-    Ok(HttpResponse::Ok().json(channel))
-}

src/api/v1/channels/uuid/socket.rs

@@ -1,111 +0,0 @@
-use actix_web::{
-    Error, HttpRequest, HttpResponse, get,
-    http::header::{HeaderValue, SEC_WEBSOCKET_PROTOCOL},
-    rt, web,
-};
-use actix_ws::AggregatedMessage;
-use futures_util::StreamExt as _;
-use uuid::Uuid;
-
-use crate::{
-    Data,
-    api::v1::auth::check_access_token,
-    objects::{Channel, Member},
-    utils::{get_ws_protocol_header, global_checks},
-};
-
-#[get("/{uuid}/socket")]
-pub async fn ws(
-    req: HttpRequest,
-    path: web::Path<(Uuid,)>,
-    stream: web::Payload,
-    data: web::Data<Data>,
-) -> Result<HttpResponse, Error> {
-    // Get all headers
-    let headers = req.headers();
-
-    // Retrieve auth header
-    let auth_header = get_ws_protocol_header(headers)?;
-
-    // Get uuid from path
-    let channel_uuid = path.into_inner().0;
-
-    let mut conn = data.pool.get().await.map_err(crate::error::Error::from)?;
-
-    // Authorize client using auth header
-    let uuid = check_access_token(auth_header, &mut conn).await?;
-
-    global_checks(&data, uuid).await?;
-
-    let channel = Channel::fetch_one(&data, channel_uuid).await?;
-
-    Member::check_membership(&mut conn, uuid, channel.guild_uuid).await?;
-
-    let (mut res, mut session_1, stream) = actix_ws::handle(&req, stream)?;
-
-    let mut stream = stream
-        .aggregate_continuations()
-        // aggregate continuation frames up to 1MiB
-        .max_continuation_size(2_usize.pow(20));
-
-    let mut pubsub = data
-        .cache_pool
-        .get_async_pubsub()
-        .await
-        .map_err(crate::error::Error::from)?;
-
-    let mut session_2 = session_1.clone();
-
-    rt::spawn(async move {
-        pubsub.subscribe(channel_uuid.to_string()).await?;
-        while let Some(msg) = pubsub.on_message().next().await {
-            let payload: String = msg.get_payload()?;
-            session_1.text(payload).await?;
-        }
-
-        Ok::<(), crate::error::Error>(())
-    });
-
-    // start task but don't wait for it
-    rt::spawn(async move {
-        // receive messages from websocket
-        while let Some(msg) = stream.next().await {
-            match msg {
-                Ok(AggregatedMessage::Text(text)) => {
-                    let mut conn = data.cache_pool.get_multiplexed_tokio_connection().await?;
-
-                    let message = channel.new_message(&data, uuid, text.to_string()).await?;
-
-                    redis::cmd("PUBLISH")
-                        .arg(&[channel_uuid.to_string(), serde_json::to_string(&message)?])
-                        .exec_async(&mut conn)
-                        .await?;
-                }
-
-                Ok(AggregatedMessage::Binary(bin)) => {
-                    // echo binary message
-                    session_2.binary(bin).await?;
-                }
-
-                Ok(AggregatedMessage::Ping(msg)) => {
-                    // respond to PING frame with PONG frame
-                    session_2.pong(&msg).await?;
-                }
-
-                _ => {}
-            }
-        }
-
-        Ok::<(), crate::error::Error>(())
-    });
-
-    let headers = res.headers_mut();
-
-    headers.append(
-        SEC_WEBSOCKET_PROTOCOL,
-        HeaderValue::from_str("Authorization")?,
-    );
-
-    // respond immediately with response connected to WS session
-    Ok(res)
-}

src/api/v1/guilds/mod.rs

@@ -1,139 +0,0 @@
-//! `/api/v1/guilds` Guild related endpoints
-
-use actix_web::{HttpRequest, HttpResponse, Scope, get, post, web};
-use serde::Deserialize;
-
-mod uuid;
-
-use crate::{
-    Data,
-    api::v1::auth::check_access_token,
-    error::Error,
-    objects::{Guild, StartAmountQuery},
-    utils::{get_auth_header, global_checks},
-};
-
-#[derive(Deserialize)]
-struct GuildInfo {
-    name: String,
-}
-
-pub fn web() -> Scope {
-    web::scope("/guilds")
-        .service(post)
-        .service(get)
-        .service(uuid::web())
-}
-
-/// `POST /api/v1/guilds` Creates a new guild
-///
-/// requires auth: yes
-///
-/// ### Request Example
-/// ```
-/// json!({
-///     "name": "My new server!"
-/// });
-/// ```
-///
-/// ### Response Example
-/// ```
-/// json!({
-///     "uuid": "383d2afa-082f-4dd3-9050-ca6ed91487b6",
-///     "name": "My new server!",
-///     "description": null,
-///     "icon": null,
-///     "owner_uuid": "155d2291-fb23-46bd-a656-ae7c5d8218e6",
-///     "roles": [],
-///     "member_count": 1
-/// });
-/// ```
-/// NOTE: UUIDs in this response are made using `uuidgen`, UUIDs made by the actual backend will be UUIDv7 and have extractable timestamps
-#[post("")]
-pub async fn post(
-    req: HttpRequest,
-    guild_info: web::Json<GuildInfo>,
-    data: web::Data<Data>,
-) -> Result<HttpResponse, Error> {
-    let headers = req.headers();
-
-    let auth_header = get_auth_header(headers)?;
-
-    let mut conn = data.pool.get().await?;
-
-    let uuid = check_access_token(auth_header, &mut conn).await?;
-
-    let guild = Guild::new(&mut conn, guild_info.name.clone(), uuid).await?;
-
-    Ok(HttpResponse::Ok().json(guild))
-}
-
-/// `GET /api/v1/servers` Fetches all guilds
-///
-/// requires auth: yes
-///
-/// requires admin: yes
-///
-/// ### Response Example
-/// ```
-/// json!([
-///     {
-///         "uuid": "383d2afa-082f-4dd3-9050-ca6ed91487b6",
-///         "name": "My new server!",
-///         "description": null,
-///         "icon": null,
-///         "owner_uuid": "155d2291-fb23-46bd-a656-ae7c5d8218e6",
-///         "roles": [],
-///         "member_count": 1
-///     },
-///     {
-///         "uuid": "5ba61ec7-5f97-43e1-89a5-d4693c155612",
-///         "name": "My first server!",
-///         "description": "This is a cool and nullable description!",
-///         "icon": "https://nullable-url/path/to/icon.png",
-///         "owner_uuid": "155d2291-fb23-46bd-a656-ae7c5d8218e6",
-///         "roles": [
-///             {
-///                 "uuid": "be0e4da4-cf73-4f45-98f8-bb1c73d1ab8b",
-///                 "guild_uuid": "5ba61ec7-5f97-43e1-89a5-d4693c155612",
-///                 "name": "Cool people",
-///                 "color": 15650773,
-///                 "is_above": c7432f1c-f4ad-4ad3-8216-51388b6abb5b,
-///                 "permissions": 0
-///             }
-///             {
-///                 "uuid": "c7432f1c-f4ad-4ad3-8216-51388b6abb5b",
-///                 "guild_uuid": "5ba61ec7-5f97-43e1-89a5-d4693c155612",
-///                 "name": "Equally cool people",
-///                 "color": 16777215,
-///                 "is_above": null,
-///                 "permissions": 0
-///             }
-///         ],
-///         "member_count": 20
-///     }
-/// ]);
-/// ```
-/// NOTE: UUIDs in this response are made using `uuidgen`, UUIDs made by the actual backend will be UUIDv7 and have extractable timestamps
-#[get("")]
-pub async fn get(
-    req: HttpRequest,
-    request_query: web::Query<StartAmountQuery>,
-    data: web::Data<Data>,
-) -> Result<HttpResponse, Error> {
-    let headers = req.headers();
-
-    let auth_header = get_auth_header(headers)?;
-
-    let start = request_query.start.unwrap_or(0);
-
-    let amount = request_query.amount.unwrap_or(10);
-
-    let uuid = check_access_token(auth_header, &mut data.pool.get().await?).await?;
-
-    global_checks(&data, uuid).await?;
-
-    let guilds = Guild::fetch_amount(&data.pool, start, amount).await?;
-
-    Ok(HttpResponse::Ok().json(guilds))
-}

src/api/v1/guilds/uuid/members.rs

@@ -1,34 +0,0 @@
-use crate::{
-    Data,
-    api::v1::auth::check_access_token,
-    error::Error,
-    objects::Member,
-    utils::{get_auth_header, global_checks},
-};
-use ::uuid::Uuid;
-use actix_web::{HttpRequest, HttpResponse, get, web};
-
-#[get("{uuid}/members")]
-pub async fn get(
-    req: HttpRequest,
-    path: web::Path<(Uuid,)>,
-    data: web::Data<Data>,
-) -> Result<HttpResponse, Error> {
-    let headers = req.headers();
-
-    let auth_header = get_auth_header(headers)?;
-
-    let guild_uuid = path.into_inner().0;
-
-    let mut conn = data.pool.get().await?;
-
-    let uuid = check_access_token(auth_header, &mut conn).await?;
-
-    global_checks(&data, uuid).await?;
-
-    Member::check_membership(&mut conn, uuid, guild_uuid).await?;
-
-    let members = Member::fetch_all(&data, guild_uuid).await?;
-
-    Ok(HttpResponse::Ok().json(members))
-}

src/api/v1/guilds/uuid/mod.rs

@@ -1,96 +0,0 @@
-//! `/api/v1/guilds/{uuid}` Specific server endpoints
-
-use actix_web::{HttpRequest, HttpResponse, Scope, get, web};
-use uuid::Uuid;
-
-mod channels;
-mod icon;
-mod invites;
-mod members;
-mod roles;
-
-use crate::{
-    Data,
-    api::v1::auth::check_access_token,
-    error::Error,
-    objects::{Guild, Member},
-    utils::{get_auth_header, global_checks},
-};
-
-pub fn web() -> Scope {
-    web::scope("")
-        // Servers
-        .service(get)
-        // Channels
-        .service(channels::get)
-        .service(channels::create)
-        // Roles
-        .service(roles::get)
-        .service(roles::create)
-        .service(roles::uuid::get)
-        // Invites
-        .service(invites::get)
-        .service(invites::create)
-        // Icon
-        .service(icon::upload)
-        // Members
-        .service(members::get)
-}
-
-/// `GET /api/v1/guilds/{uuid}` DESCRIPTION
-///
-/// requires auth: yes
-///
-/// ### Response Example
-/// ```
-/// json!({
-///         "uuid": "5ba61ec7-5f97-43e1-89a5-d4693c155612",
-///         "name": "My first server!",
-///         "description": "This is a cool and nullable description!",
-///         "icon": "https://nullable-url/path/to/icon.png",
-///         "owner_uuid": "155d2291-fb23-46bd-a656-ae7c5d8218e6",
-///         "roles": [
-///             {
-///                 "uuid": "be0e4da4-cf73-4f45-98f8-bb1c73d1ab8b",
-///                 "guild_uuid": "5ba61ec7-5f97-43e1-89a5-d4693c155612",
-///                 "name": "Cool people",
-///                 "color": 15650773,
-///                 "is_above": c7432f1c-f4ad-4ad3-8216-51388b6abb5b,
-///                 "permissions": 0
-///             }
-///             {
-///                 "uuid": "c7432f1c-f4ad-4ad3-8216-51388b6abb5b",
-///                 "guild_uuid": "5ba61ec7-5f97-43e1-89a5-d4693c155612",
-///                 "name": "Equally cool people",
-///                 "color": 16777215,
-///                 "is_above": null,
-///                 "permissions": 0
-///             }
-///         ],
-///         "member_count": 20
-/// });
-/// ```
-#[get("/{uuid}")]
-pub async fn get(
-    req: HttpRequest,
-    path: web::Path<(Uuid,)>,
-    data: web::Data<Data>,
-) -> Result<HttpResponse, Error> {
-    let headers = req.headers();
-
-    let auth_header = get_auth_header(headers)?;
-
-    let guild_uuid = path.into_inner().0;
-
-    let mut conn = data.pool.get().await?;
-
-    let uuid = check_access_token(auth_header, &mut conn).await?;
-
-    global_checks(&data, uuid).await?;
-
-    Member::check_membership(&mut conn, uuid, guild_uuid).await?;
-
-    let guild = Guild::fetch_one(&mut conn, guild_uuid).await?;
-
-    Ok(HttpResponse::Ok().json(guild))
-}

src/api/v1/invites/id.rs

@@ -4,14 +4,24 @@ use crate::{
     Data,
     api::v1::auth::check_access_token,
     error::Error,
-    objects::{Guild, Invite, Member},
+    structs::{Guild, Invite, Member},
-    utils::{get_auth_header, global_checks},
+    utils::get_auth_header,
 };
 
 #[get("{id}")]
-pub async fn get(path: web::Path<(String,)>, data: web::Data<Data>) -> Result<HttpResponse, Error> {
+pub async fn get(
+    req: HttpRequest,
+    path: web::Path<(String,)>,
+    data: web::Data<Data>,
+) -> Result<HttpResponse, Error> {
+    let headers = req.headers();
+
+    let auth_header = get_auth_header(headers)?;
+
     let mut conn = data.pool.get().await?;
 
+    check_access_token(auth_header, &mut conn).await?;
+
     let invite_id = path.into_inner().0;
 
     let invite = Invite::fetch_one(&mut conn, invite_id).await?;
@@ -37,13 +47,11 @@ pub async fn join(
 
     let uuid = check_access_token(auth_header, &mut conn).await?;
 
-    global_checks(&data, uuid).await?;
-
     let invite = Invite::fetch_one(&mut conn, invite_id).await?;
 
     let guild = Guild::fetch_one(&mut conn, invite.guild_uuid).await?;
 
-    Member::new(&data, uuid, guild.uuid).await?;
+    Member::new(&mut conn, uuid, guild.uuid).await?;
 
     Ok(HttpResponse::Ok().json(guild))
 }

src/api/v1/me/guilds.rs

@@ -1,75 +0,0 @@
-//! `/api/v1/me/guilds` Contains endpoint related to guild memberships
-
-use actix_web::{HttpRequest, HttpResponse, get, web};
-
-use crate::{
-    Data,
-    api::v1::auth::check_access_token,
-    error::Error,
-    objects::Me,
-    utils::{get_auth_header, global_checks},
-};
-
-/// `GET /api/v1/me/guilds` Returns all guild memberships in a list
-///
-/// requires auth: yes
-///
-/// ### Example Response
-/// ```
-/// json!([
-///     {
-///         "uuid": "383d2afa-082f-4dd3-9050-ca6ed91487b6",
-///         "name": "My new server!",
-///         "description": null,
-///         "icon": null,
-///         "owner_uuid": "155d2291-fb23-46bd-a656-ae7c5d8218e6",
-///         "roles": [],
-///         "member_count": 1
-///     },
-///     {
-///         "uuid": "5ba61ec7-5f97-43e1-89a5-d4693c155612",
-///         "name": "My first server!",
-///         "description": "This is a cool and nullable description!",
-///         "icon": "https://nullable-url/path/to/icon.png",
-///         "owner_uuid": "155d2291-fb23-46bd-a656-ae7c5d8218e6",
-///         "roles": [
-///             {
-///                 "uuid": "be0e4da4-cf73-4f45-98f8-bb1c73d1ab8b",
-///                 "guild_uuid": "5ba61ec7-5f97-43e1-89a5-d4693c155612",
-///                 "name": "Cool people",
-///                 "color": 15650773,
-///                 "is_above": c7432f1c-f4ad-4ad3-8216-51388b6abb5b,
-///                 "permissions": 0
-///             }
-///             {
-///                 "uuid": "c7432f1c-f4ad-4ad3-8216-51388b6abb5b",
-///                 "guild_uuid": "5ba61ec7-5f97-43e1-89a5-d4693c155612",
-///                 "name": "Equally cool people",
-///                 "color": 16777215,
-///                 "is_above": null,
-///                 "permissions": 0
-///             }
-///         ],
-///         "member_count": 20
-///     }
-/// ]);
-/// ```
-/// NOTE: UUIDs in this response are made using `uuidgen`, UUIDs made by the actual backend will be UUIDv7 and have extractable timestamps
-#[get("/guilds")]
-pub async fn get(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse, Error> {
-    let headers = req.headers();
-
-    let auth_header = get_auth_header(headers)?;
-
-    let mut conn = data.pool.get().await?;
-
-    let uuid = check_access_token(auth_header, &mut conn).await?;
-
-    global_checks(&data, uuid).await?;
-
-    let me = Me::get(&mut conn, uuid).await?;
-
-    let memberships = me.fetch_memberships(&mut conn).await?;
-
-    Ok(HttpResponse::Ok().json(memberships))
-}

src/api/v1/me/mod.rs

@@ -1,104 +0,0 @@
-use actix_multipart::form::{MultipartForm, json::Json as MpJson, tempfile::TempFile};
-use actix_web::{HttpRequest, HttpResponse, Scope, get, patch, web};
-use serde::Deserialize;
-
-use crate::{
-    Data,
-    api::v1::auth::check_access_token,
-    error::Error,
-    objects::Me,
-    utils::{get_auth_header, global_checks},
-};
-
-mod guilds;
-
-pub fn web() -> Scope {
-    web::scope("/me")
-        .service(get)
-        .service(update)
-        .service(guilds::get)
-}
-
-#[get("")]
-pub async fn get(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse, Error> {
-    let headers = req.headers();
-
-    let auth_header = get_auth_header(headers)?;
-
-    let mut conn = data.pool.get().await?;
-
-    let uuid = check_access_token(auth_header, &mut conn).await?;
-
-    let me = Me::get(&mut conn, uuid).await?;
-
-    Ok(HttpResponse::Ok().json(me))
-}
-
-#[derive(Debug, Deserialize, Clone)]
-struct NewInfo {
-    username: Option<String>,
-    display_name: Option<String>,
-    //password: Option<String>, will probably be handled through a reset password link
-    email: Option<String>,
-    pronouns: Option<String>,
-    about: Option<String>,
-}
-
-#[derive(Debug, MultipartForm)]
-struct UploadForm {
-    #[multipart(limit = "100MB")]
-    avatar: Option<TempFile>,
-    json: MpJson<NewInfo>,
-}
-
-#[patch("")]
-pub async fn update(
-    req: HttpRequest,
-    MultipartForm(form): MultipartForm<UploadForm>,
-    data: web::Data<Data>,
-) -> Result<HttpResponse, Error> {
-    let headers = req.headers();
-
-    let auth_header = get_auth_header(headers)?;
-
-    let mut conn = data.pool.get().await?;
-
-    let uuid = check_access_token(auth_header, &mut conn).await?;
-
-    if form.avatar.is_some() || form.json.username.is_some() || form.json.display_name.is_some() {
-        global_checks(&data, uuid).await?;
-    }
-
-    let mut me = Me::get(&mut conn, uuid).await?;
-
-    if let Some(avatar) = form.avatar {
-        let bytes = tokio::fs::read(avatar.file).await?;
-
-        let byte_slice: &[u8] = &bytes;
-
-        me.set_avatar(&data, data.config.bunny.cdn_url.clone(), byte_slice.into())
-            .await?;
-    }
-
-    if let Some(username) = &form.json.username {
-        me.set_username(&data, username.clone()).await?;
-    }
-
-    if let Some(display_name) = &form.json.display_name {
-        me.set_display_name(&data, display_name.clone()).await?;
-    }
-
-    if let Some(email) = &form.json.email {
-        me.set_email(&data, email.clone()).await?;
-    }
-
-    if let Some(pronouns) = &form.json.pronouns {
-        me.set_pronouns(&data, pronouns.clone()).await?;
-    }
-
-    if let Some(about) = &form.json.about {
-        me.set_about(&data, about.clone()).await?;
-    }
-
-    Ok(HttpResponse::Ok().finish())
-}

src/api/v1/mod.rs

@@ -1,12 +1,8 @@
-//! `/api/v1` Contains version 1 of the api
-
 use actix_web::{Scope, web};
 
 mod auth;
-mod channels;
-mod guilds;
 mod invites;
-mod me;
+mod servers;
 mod stats;
 mod users;
 
@@ -15,8 +11,6 @@ pub fn web() -> Scope {
         .service(stats::res)
         .service(auth::web())
         .service(users::web())
-        .service(channels::web())
+        .service(servers::web())
-        .service(guilds::web())
         .service(invites::web())
-        .service(me::web())
 }

src/api/v1/servers/mod.rs

@@ -0,0 +1,71 @@
+use actix_web::{HttpRequest, HttpResponse, Scope, get, post, web};
+use serde::Deserialize;
+
+mod uuid;
+
+use crate::{
+    Data,
+    api::v1::auth::check_access_token,
+    error::Error,
+    structs::{Guild, StartAmountQuery},
+    utils::get_auth_header,
+};
+
+#[derive(Deserialize)]
+struct GuildInfo {
+    name: String,
+    description: Option<String>,
+}
+
+pub fn web() -> Scope {
+    web::scope("/servers")
+        .service(create)
+        .service(get)
+        .service(uuid::web())
+}
+
+#[post("")]
+pub async fn create(
+    req: HttpRequest,
+    guild_info: web::Json<GuildInfo>,
+    data: web::Data<Data>,
+) -> Result<HttpResponse, Error> {
+    let headers = req.headers();
+
+    let auth_header = get_auth_header(headers)?;
+
+    let mut conn = data.pool.get().await?;
+
+    let uuid = check_access_token(auth_header, &mut conn).await?;
+
+    let guild = Guild::new(
+        &mut conn,
+        guild_info.name.clone(),
+        guild_info.description.clone(),
+        uuid,
+    )
+    .await?;
+
+    Ok(HttpResponse::Ok().json(guild))
+}
+
+#[get("")]
+pub async fn get(
+    req: HttpRequest,
+    request_query: web::Query<StartAmountQuery>,
+    data: web::Data<Data>,
+) -> Result<HttpResponse, Error> {
+    let headers = req.headers();
+
+    let auth_header = get_auth_header(headers)?;
+
+    let start = request_query.start.unwrap_or(0);
+
+    let amount = request_query.amount.unwrap_or(10);
+
+    check_access_token(auth_header, &mut data.pool.get().await.unwrap()).await?;
+
+    let guilds = Guild::fetch_amount(&data.pool, start, amount).await?;
+
+    Ok(HttpResponse::Ok().json(guilds))
+}

src/api/v1/servers/uuid/channels/mod.rs

@@ -1,10 +1,16 @@
 use crate::{
-    api::v1::auth::check_access_token, error::Error, objects::{Channel, Member, Permissions}, utils::{get_auth_header, global_checks, order_by_is_above}, Data
+    Data,
+    api::v1::auth::check_access_token,
+    error::Error,
+    structs::{Channel, Member},
+    utils::get_auth_header,
 };
 use ::uuid::Uuid;
 use actix_web::{HttpRequest, HttpResponse, get, post, web};
 use serde::Deserialize;
 
+pub mod uuid;
+
 #[derive(Deserialize)]
 struct ChannelInfo {
     name: String,
@@ -27,9 +33,7 @@ pub async fn get(
 
     let uuid = check_access_token(auth_header, &mut conn).await?;
 
-    global_checks(&data, uuid).await?;
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
-
-    Member::check_membership(&mut conn, uuid, guild_uuid).await?;
 
     if let Ok(cache_hit) = data.get_cache_key(format!("{}_channels", guild_uuid)).await {
         return Ok(HttpResponse::Ok()
@@ -39,16 +43,10 @@ pub async fn get(
 
     let channels = Channel::fetch_all(&data.pool, guild_uuid).await?;
 
-    let channels_ordered = order_by_is_above(channels).await?;
+    data.set_cache_key(format!("{}_channels", guild_uuid), channels.clone(), 1800)
-
-    data.set_cache_key(
-        format!("{}_channels", guild_uuid),
-        channels_ordered.clone(),
-        1800,
-    )
         .await?;
 
-    Ok(HttpResponse::Ok().json(channels_ordered))
+    Ok(HttpResponse::Ok().json(channels))
 }
 
 #[post("{uuid}/channels")]
@@ -68,11 +66,9 @@ pub async fn create(
 
     let uuid = check_access_token(auth_header, &mut conn).await?;
 
-    global_checks(&data, uuid).await?;
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
 
-    let member = Member::check_membership(&mut conn, uuid, guild_uuid).await?;
+    // FIXME: Logic to check permissions, should probably be done in utils.rs
-
-    member.check_permission(&data, Permissions::CreateChannel).await?;
 
     let channel = Channel::new(
         data.clone(),
@@ -80,7 +76,7 @@ pub async fn create(
         channel_info.name.clone(),
         channel_info.description.clone(),
     )
-    .await?;
+    .await;
 
-    Ok(HttpResponse::Ok().json(channel))
+    Ok(HttpResponse::Ok().json(channel.unwrap()))
 }

src/api/v1/servers/uuid/channels/uuid/messages.rs

@@ -0,0 +1,53 @@
+use crate::{
+    Data,
+    api::v1::auth::check_access_token,
+    error::Error,
+    structs::{Channel, Member},
+    utils::get_auth_header,
+};
+use ::uuid::Uuid;
+use actix_web::{HttpRequest, HttpResponse, get, web};
+use serde::Deserialize;
+
+#[derive(Deserialize)]
+struct MessageRequest {
+    amount: i64,
+    offset: i64,
+}
+
+#[get("{uuid}/channels/{channel_uuid}/messages")]
+pub async fn get(
+    req: HttpRequest,
+    path: web::Path<(Uuid, Uuid)>,
+    message_request: web::Query<MessageRequest>,
+    data: web::Data<Data>,
+) -> Result<HttpResponse, Error> {
+    let headers = req.headers();
+
+    let auth_header = get_auth_header(headers)?;
+
+    let (guild_uuid, channel_uuid) = path.into_inner();
+
+    let mut conn = data.pool.get().await?;
+
+    let uuid = check_access_token(auth_header, &mut conn).await?;
+
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
+
+    let channel: Channel;
+
+    if let Ok(cache_hit) = data.get_cache_key(format!("{}", channel_uuid)).await {
+        channel = serde_json::from_str(&cache_hit)?
+    } else {
+        channel = Channel::fetch_one(&mut conn, channel_uuid).await?;
+
+        data.set_cache_key(format!("{}", channel_uuid), channel.clone(), 60)
+            .await?;
+    }
+
+    let messages = channel
+        .fetch_messages(&mut conn, message_request.amount, message_request.offset)
+        .await?;
+
+    Ok(HttpResponse::Ok().json(messages))
+}

src/api/v1/servers/uuid/channels/uuid/mod.rs

@@ -0,0 +1,77 @@
+pub mod messages;
+pub mod socket;
+
+use crate::{
+    Data,
+    api::v1::auth::check_access_token,
+    error::Error,
+    structs::{Channel, Member},
+    utils::get_auth_header,
+};
+use actix_web::{HttpRequest, HttpResponse, delete, get, web};
+use uuid::Uuid;
+
+#[get("{uuid}/channels/{channel_uuid}")]
+pub async fn get(
+    req: HttpRequest,
+    path: web::Path<(Uuid, Uuid)>,
+    data: web::Data<Data>,
+) -> Result<HttpResponse, Error> {
+    let headers = req.headers();
+
+    let auth_header = get_auth_header(headers)?;
+
+    let (guild_uuid, channel_uuid) = path.into_inner();
+
+    let mut conn = data.pool.get().await?;
+
+    let uuid = check_access_token(auth_header, &mut conn).await?;
+
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
+
+    if let Ok(cache_hit) = data.get_cache_key(format!("{}", channel_uuid)).await {
+        return Ok(HttpResponse::Ok()
+            .content_type("application/json")
+            .body(cache_hit));
+    }
+
+    let channel = Channel::fetch_one(&mut conn, channel_uuid).await?;
+
+    data.set_cache_key(format!("{}", channel_uuid), channel.clone(), 60)
+        .await?;
+
+    Ok(HttpResponse::Ok().json(channel))
+}
+
+#[delete("{uuid}/channels/{channel_uuid}")]
+pub async fn delete(
+    req: HttpRequest,
+    path: web::Path<(Uuid, Uuid)>,
+    data: web::Data<Data>,
+) -> Result<HttpResponse, Error> {
+    let headers = req.headers();
+
+    let auth_header = get_auth_header(headers)?;
+
+    let (guild_uuid, channel_uuid) = path.into_inner();
+
+    let mut conn = data.pool.get().await?;
+
+    let uuid = check_access_token(auth_header, &mut conn).await?;
+
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
+
+    let channel: Channel;
+
+    if let Ok(cache_hit) = data.get_cache_key(format!("{}", channel_uuid)).await {
+        channel = serde_json::from_str(&cache_hit).unwrap();
+
+        data.del_cache_key(format!("{}", channel_uuid)).await?;
+    } else {
+        channel = Channel::fetch_one(&mut conn, channel_uuid).await?;
+    }
+
+    channel.delete(&mut conn).await?;
+
+    Ok(HttpResponse::Ok().finish())
+}

src/api/v1/servers/uuid/channels/uuid/socket.rs

@@ -0,0 +1,112 @@
+use actix_web::{Error, HttpRequest, HttpResponse, get, rt, web};
+use actix_ws::AggregatedMessage;
+use futures_util::StreamExt as _;
+use uuid::Uuid;
+
+use crate::{
+    Data,
+    api::v1::auth::check_access_token,
+    structs::{Channel, Member},
+    utils::get_auth_header,
+};
+
+#[get("{uuid}/channels/{channel_uuid}/socket")]
+pub async fn echo(
+    req: HttpRequest,
+    path: web::Path<(Uuid, Uuid)>,
+    stream: web::Payload,
+    data: web::Data<Data>,
+) -> Result<HttpResponse, Error> {
+    // Get all headers
+    let headers = req.headers();
+
+    // Retrieve auth header
+    let auth_header = get_auth_header(headers)?;
+
+    // Get uuids from path
+    let (guild_uuid, channel_uuid) = path.into_inner();
+
+    let mut conn = data.pool.get().await.map_err(crate::error::Error::from)?;
+
+    // Authorize client using auth header
+    let uuid = check_access_token(auth_header, &mut conn).await?;
+
+    // Get server member from psql
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
+
+    let channel: Channel;
+
+    // Return channel cache or result from psql as `channel` variable
+    if let Ok(cache_hit) = data.get_cache_key(format!("{}", channel_uuid)).await {
+        channel = serde_json::from_str(&cache_hit).unwrap()
+    } else {
+        channel = Channel::fetch_one(&mut conn, channel_uuid).await?;
+
+        data.set_cache_key(format!("{}", channel_uuid), channel.clone(), 60)
+            .await?;
+    }
+
+    let (res, mut session_1, stream) = actix_ws::handle(&req, stream)?;
+
+    let mut stream = stream
+        .aggregate_continuations()
+        // aggregate continuation frames up to 1MiB
+        .max_continuation_size(2_usize.pow(20));
+
+    let mut pubsub = data
+        .cache_pool
+        .get_async_pubsub()
+        .await
+        .map_err(crate::error::Error::from)?;
+
+    let mut session_2 = session_1.clone();
+
+    rt::spawn(async move {
+        pubsub.subscribe(channel_uuid.to_string()).await.unwrap();
+        while let Some(msg) = pubsub.on_message().next().await {
+            let payload: String = msg.get_payload().unwrap();
+            session_1.text(payload).await.unwrap();
+        }
+    });
+
+    // start task but don't wait for it
+    rt::spawn(async move {
+        let mut conn = data
+            .cache_pool
+            .get_multiplexed_tokio_connection()
+            .await
+            .unwrap();
+        // receive messages from websocket
+        while let Some(msg) = stream.next().await {
+            match msg {
+                Ok(AggregatedMessage::Text(text)) => {
+                    // echo text message
+                    redis::cmd("PUBLISH")
+                        .arg(&[channel_uuid.to_string(), text.to_string()])
+                        .exec_async(&mut conn)
+                        .await
+                        .unwrap();
+                    channel
+                        .new_message(&mut data.pool.get().await.unwrap(), uuid, text.to_string())
+                        .await
+                        .unwrap();
+                }
+
+                Ok(AggregatedMessage::Binary(bin)) => {
+                    // echo binary message
+                    session_2.binary(bin).await.unwrap();
+                }
+
+                Ok(AggregatedMessage::Ping(msg)) => {
+                    // respond to PING frame with PONG frame
+                    session_2.pong(&msg).await.unwrap();
+                }
+
+                _ => {}
+            }
+        }
+    });
+
+    // respond immediately with response connected to WS session
+    Ok(res)
+}

src/api/v1/servers/uuid/icon.rs

@@ -1,18 +1,15 @@
-//! `/api/v1/guilds/{uuid}/icon` icon related endpoints, will probably be replaced by a multipart post to above endpoint
-
 use actix_web::{HttpRequest, HttpResponse, put, web};
 use futures_util::StreamExt as _;
 use uuid::Uuid;
 
 use crate::{
-    api::v1::auth::check_access_token, error::Error, objects::{Guild, Member, Permissions}, utils::{get_auth_header, global_checks}, Data
+    Data,
+    api::v1::auth::check_access_token,
+    error::Error,
+    structs::{Guild, Member},
+    utils::get_auth_header,
 };
 
-/// `PUT /api/v1/guilds/{uuid}/icon` Icon upload
-///
-/// requires auth: no
-///
-/// put request expects a file and nothing else
 #[put("{uuid}/icon")]
 pub async fn upload(
     req: HttpRequest,
@@ -30,11 +27,7 @@ pub async fn upload(
 
     let uuid = check_access_token(auth_header, &mut conn).await?;
 
-    global_checks(&data, uuid).await?;
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
-
-    let member = Member::check_membership(&mut conn, uuid, guild_uuid).await?;
-
-    member.check_permission(&data, Permissions::ManageServer).await?;
 
     let mut guild = Guild::fetch_one(&mut conn, guild_uuid).await?;
 
@@ -45,9 +38,8 @@ pub async fn upload(
 
     guild
         .set_icon(
-            &data.bunny_storage,
+            &data.storage,
             &mut conn,
-            data.config.bunny.cdn_url.clone(),
             bytes,
         )
         .await?;

src/api/v1/servers/uuid/invites/mod.rs

@@ -3,12 +3,16 @@ use serde::Deserialize;
 use uuid::Uuid;
 
 use crate::{
-    api::v1::auth::check_access_token, error::Error, objects::{Guild, Member, Permissions}, utils::{get_auth_header, global_checks}, Data
+    Data,
+    api::v1::auth::check_access_token,
+    error::Error,
+    structs::{Guild, Member},
+    utils::get_auth_header,
 };
 
 #[derive(Deserialize)]
 struct InviteRequest {
-    custom_id: Option<String>,
+    custom_id: String,
 }
 
 #[get("{uuid}/invites")]
@@ -27,9 +31,7 @@ pub async fn get(
 
     let uuid = check_access_token(auth_header, &mut conn).await?;
 
-    global_checks(&data, uuid).await?;
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
-
-    Member::check_membership(&mut conn, uuid, guild_uuid).await?;
 
     let guild = Guild::fetch_one(&mut conn, guild_uuid).await?;
 
@@ -42,7 +44,7 @@ pub async fn get(
 pub async fn create(
     req: HttpRequest,
     path: web::Path<(Uuid,)>,
-    invite_request: web::Json<InviteRequest>,
+    invite_request: web::Json<Option<InviteRequest>>,
     data: web::Data<Data>,
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
@@ -55,15 +57,13 @@ pub async fn create(
 
     let uuid = check_access_token(auth_header, &mut conn).await?;
 
-    global_checks(&data, uuid).await?;
+    let member = Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
-
-    let member = Member::check_membership(&mut conn, uuid, guild_uuid).await?;
-
-    member.check_permission(&data, Permissions::CreateInvite).await?;
 
     let guild = Guild::fetch_one(&mut conn, guild_uuid).await?;
 
-    let invite = guild.create_invite(&mut conn, uuid, invite_request.custom_id.clone()).await?;
+    let custom_id = invite_request.as_ref().map(|ir| ir.custom_id.clone());
+
+    let invite = guild.create_invite(&mut conn, &member, custom_id).await?;
 
     Ok(HttpResponse::Ok().json(invite))
 }

src/api/v1/servers/uuid/mod.rs

@@ -0,0 +1,60 @@
+use actix_web::{HttpRequest, HttpResponse, Scope, get, web};
+use uuid::Uuid;
+
+mod channels;
+mod icon;
+mod invites;
+mod roles;
+
+use crate::{
+    Data,
+    api::v1::auth::check_access_token,
+    error::Error,
+    structs::{Guild, Member},
+    utils::get_auth_header,
+};
+
+pub fn web() -> Scope {
+    web::scope("")
+        // Servers
+        .service(res)
+        // Channels
+        .service(channels::get)
+        .service(channels::create)
+        .service(channels::uuid::get)
+        .service(channels::uuid::delete)
+        .service(channels::uuid::messages::get)
+        .service(channels::uuid::socket::echo)
+        // Roles
+        .service(roles::get)
+        .service(roles::create)
+        .service(roles::uuid::get)
+        // Invites
+        .service(invites::get)
+        .service(invites::create)
+        // Icon
+        .service(icon::upload)
+}
+
+#[get("/{uuid}")]
+pub async fn res(
+    req: HttpRequest,
+    path: web::Path<(Uuid,)>,
+    data: web::Data<Data>,
+) -> Result<HttpResponse, Error> {
+    let headers = req.headers();
+
+    let auth_header = get_auth_header(headers)?;
+
+    let guild_uuid = path.into_inner().0;
+
+    let mut conn = data.pool.get().await?;
+
+    let uuid = check_access_token(auth_header, &mut conn).await?;
+
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
+
+    let guild = Guild::fetch_one(&mut conn, guild_uuid).await?;
+
+    Ok(HttpResponse::Ok().json(guild))
+}

src/api/v1/servers/uuid/roles/mod.rs

@@ -3,7 +3,11 @@ use actix_web::{HttpRequest, HttpResponse, get, post, web};
 use serde::Deserialize;
 
 use crate::{
-    api::v1::auth::check_access_token, error::Error, objects::{Member, Permissions, Role}, utils::{get_auth_header, global_checks, order_by_is_above}, Data
+    Data,
+    api::v1::auth::check_access_token,
+    error::Error,
+    structs::{Member, Role},
+    utils::get_auth_header,
 };
 
 pub mod uuid;
@@ -29,7 +33,7 @@ pub async fn get(
 
     let uuid = check_access_token(auth_header, &mut conn).await?;
 
-    Member::check_membership(&mut conn, uuid, guild_uuid).await?;
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
 
     if let Ok(cache_hit) = data.get_cache_key(format!("{}_roles", guild_uuid)).await {
         return Ok(HttpResponse::Ok()
@@ -39,12 +43,10 @@ pub async fn get(
 
     let roles = Role::fetch_all(&mut conn, guild_uuid).await?;
 
-    let roles_ordered = order_by_is_above(roles).await?;
+    data.set_cache_key(format!("{}_roles", guild_uuid), roles.clone(), 1800)
-
-    data.set_cache_key(format!("{}_roles", guild_uuid), roles_ordered.clone(), 1800)
         .await?;
 
-    Ok(HttpResponse::Ok().json(roles_ordered))
+    Ok(HttpResponse::Ok().json(roles))
 }
 
 #[post("{uuid}/roles")]
@@ -60,15 +62,13 @@ pub async fn create(
 
     let guild_uuid = path.into_inner().0;
 
-    let mut conn = data.pool.get().await?;
+    let mut conn = data.pool.get().await.unwrap();
 
     let uuid = check_access_token(auth_header, &mut conn).await?;
 
-    global_checks(&data, uuid).await?;
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
 
-    let member = Member::check_membership(&mut conn, uuid, guild_uuid).await?;
+    // FIXME: Logic to check permissions, should probably be done in utils.rs
-
-    member.check_permission(&data, Permissions::CreateRole).await?;
 
     let role = Role::new(&mut conn, guild_uuid, role_info.name.clone()).await?;
 

src/api/v1/servers/uuid/roles/uuid.rs

@@ -2,8 +2,8 @@ use crate::{
     Data,
     api::v1::auth::check_access_token,
     error::Error,
-    objects::{Member, Role},
+    structs::{Member, Role},
-    utils::{get_auth_header, global_checks},
+    utils::get_auth_header,
 };
 use ::uuid::Uuid;
 use actix_web::{HttpRequest, HttpResponse, get, web};
@@ -24,9 +24,7 @@ pub async fn get(
 
     let uuid = check_access_token(auth_header, &mut conn).await?;
 
-    global_checks(&data, uuid).await?;
+    Member::fetch_one(&mut conn, uuid, guild_uuid).await?;
-
-    Member::check_membership(&mut conn, uuid, guild_uuid).await?;
 
     if let Ok(cache_hit) = data.get_cache_key(format!("{}", role_uuid)).await {
         return Ok(HttpResponse::Ok()

src/api/v1/stats.rs

@@ -1,5 +1,3 @@
-//! `/api/v1/stats` Returns stats about the server
-
 use std::time::SystemTime;
 
 use actix_web::{HttpResponse, get, web};
@@ -12,33 +10,15 @@ use crate::error::Error;
 use crate::schema::users::dsl::{users, uuid};
 
 const VERSION: Option<&'static str> = option_env!("CARGO_PKG_VERSION");
-const GIT_SHORT_HASH: &str = env!("GIT_SHORT_HASH");
 
 #[derive(Serialize)]
 struct Response {
     accounts: i64,
     uptime: u64,
     version: String,
-    registration_enabled: bool,
-    email_verification_required: bool,
     build_number: String,
 }
 
-/// `GET /api/v1/stats` Returns stats about the server
-///
-/// requires auth: no
-///
-/// ### Response Example
-/// ```
-/// json!({
-///     "accounts": 3,
-///     "uptime": 50000,
-///     "version": "0.1.0",
-///     "registration_enabled": true,
-///     "email_verification_required": true,
-///     "build_number": "39d01bb"
-/// });
-/// ```
 #[get("/stats")]
 pub async fn res(data: web::Data<Data>) -> Result<HttpResponse, Error> {
     let accounts: i64 = users
@@ -55,10 +35,8 @@ pub async fn res(data: web::Data<Data>) -> Result<HttpResponse, Error> {
             .expect("Seriously why dont you have time??")
             .as_secs(),
         version: String::from(VERSION.unwrap_or("UNKNOWN")),
-        registration_enabled: data.config.instance.registration,
-        email_verification_required: data.config.instance.require_email_verification,
         // TODO: Get build number from git hash or remove this from the spec
-        build_number: String::from(GIT_SHORT_HASH),
+        build_number: String::from("how do i implement this?"),
     };
 
     Ok(HttpResponse::Ok().json(response))

src/api/v1/users/me.rs

@@ -0,0 +1,87 @@
+use actix_multipart::form::{MultipartForm, json::Json as MpJson, tempfile::TempFile};
+use actix_web::{HttpRequest, HttpResponse, get, patch, web};
+use serde::Deserialize;
+
+use crate::{
+    Data, api::v1::auth::check_access_token, error::Error, structs::Me, utils::get_auth_header,
+};
+
+#[get("/me")]
+pub async fn res(req: HttpRequest, data: web::Data<Data>) -> Result<HttpResponse, Error> {
+    let headers = req.headers();
+
+    let auth_header = get_auth_header(headers)?;
+
+    let mut conn = data.pool.get().await?;
+
+    let uuid = check_access_token(auth_header, &mut conn).await?;
+
+    let me = Me::get(&mut conn, uuid).await?;
+
+    Ok(HttpResponse::Ok().json(me))
+}
+
+#[derive(Debug, Deserialize)]
+struct NewInfo {
+    username: Option<String>,
+    display_name: Option<String>,
+    password: Option<String>,
+    email: Option<String>,
+}
+
+#[derive(Debug, MultipartForm)]
+struct UploadForm {
+    #[multipart(limit = "100MB")]
+    avatar: Option<TempFile>,
+    json: Option<MpJson<NewInfo>>,
+}
+
+#[patch("/me")]
+pub async fn update(
+    req: HttpRequest,
+    MultipartForm(form): MultipartForm<UploadForm>,
+    data: web::Data<Data>,
+) -> Result<HttpResponse, Error> {
+    let headers = req.headers();
+
+    let auth_header = get_auth_header(headers)?;
+
+    let mut conn = data.pool.get().await?;
+
+    let uuid = check_access_token(auth_header, &mut conn).await?;
+
+    let mut me = Me::get(&mut conn, uuid).await?;
+
+    if let Some(avatar) = form.avatar {
+        let bytes = tokio::fs::read(avatar.file).await?;
+
+        let byte_slice: &[u8] = &bytes;
+
+        me.set_avatar(
+            &data.storage,
+            &mut conn,
+            byte_slice.into(),
+        )
+        .await?;
+    }
+
+    if let Some(new_info) = form.json {
+        if let Some(username) = &new_info.username {
+            todo!();
+        }
+
+        if let Some(display_name) = &new_info.display_name {
+            todo!();
+        }
+
+        if let Some(password) = &new_info.password {
+            todo!();
+        }
+
+        if let Some(email) = &new_info.email {
+            todo!();
+        }
+    }
+
+    Ok(HttpResponse::Ok().finish())
+}

src/api/v1/users/mod.rs

@@ -1,53 +1,26 @@
-//! `/api/v1/users` Contains endpoints related to all users
-
 use actix_web::{HttpRequest, HttpResponse, Scope, get, web};
 
 use crate::{
     Data,
     api::v1::auth::check_access_token,
     error::Error,
-    objects::{StartAmountQuery, User},
+    structs::{StartAmountQuery, User},
-    utils::{get_auth_header, global_checks},
+    utils::get_auth_header,
 };
 
+mod me;
 mod uuid;
 
 pub fn web() -> Scope {
-    web::scope("/users").service(get).service(uuid::get)
+    web::scope("/users")
+        .service(res)
+        .service(me::res)
+        .service(me::update)
+        .service(uuid::res)
 }
 
-/// `GET /api/v1/users` Returns all users on this instance
-///
-/// requires auth: yes
-///
-/// requires admin: yes
-///
-/// ### Response Example
-/// ```
-/// json!([
-///     {
-///         "uuid": "155d2291-fb23-46bd-a656-ae7c5d8218e6",
-///         "username": "user1",
-///         "display_name": "Nullable Name",
-///         "avatar": "https://nullable-url.com/path/to/image.png"
-///     },
-///     {
-///         "uuid": "d48a3317-7b4d-443f-a250-ea9ab2bb8661",
-///         "username": "user2",
-///         "display_name": "John User 2",
-///         "avatar": "https://also-supports-jpg.com/path/to/image.jpg"
-///     },
-///     {
-///         "uuid": "12c4b3f8-a25b-4b9b-8136-b275c855ed4a",
-///         "username": "user3",
-///         "display_name": null,
-///         "avatar": null
-///     }
-/// ]);
-/// ```
-/// NOTE: UUIDs in this response are made using `uuidgen`, UUIDs made by the actual backend will be UUIDv7 and have extractable timestamps
 #[get("")]
-pub async fn get(
+pub async fn res(
     req: HttpRequest,
     request_query: web::Query<StartAmountQuery>,
     data: web::Data<Data>,
@@ -66,9 +39,7 @@ pub async fn get(
 
     let mut conn = data.pool.get().await?;
 
-    let uuid = check_access_token(auth_header, &mut conn).await?;
+    check_access_token(auth_header, &mut conn).await?;
-
-    global_checks(&data, uuid).await?;
 
     let users = User::fetch_amount(&mut conn, start, amount).await?;
 

src/api/v1/users/uuid.rs

@@ -1,51 +1,36 @@
-//! `/api/v1/users/{uuid}` Specific user endpoints
-
 use actix_web::{HttpRequest, HttpResponse, get, web};
 use uuid::Uuid;
 
 use crate::{
-    Data,
+    Data, api::v1::auth::check_access_token, error::Error, structs::User, utils::get_auth_header,
-    api::v1::auth::check_access_token,
-    error::Error,
-    objects::User,
-    utils::{get_auth_header, global_checks},
 };
 
-/// `GET /api/v1/users/{uuid}` Returns user with the given UUID
-///
-/// requires auth: yes
-///
-/// requires relation: yes
-///
-/// ### Response Example
-/// ```
-/// json!({
-///         "uuid": "155d2291-fb23-46bd-a656-ae7c5d8218e6",
-///         "username": "user1",
-///         "display_name": "Nullable Name",
-///         "avatar": "https://nullable-url.com/path/to/image.png"
-/// });
-/// ```
-/// NOTE: UUIDs in this response are made using `uuidgen`, UUIDs made by the actual backend will be UUIDv7 and have extractable timestamps
 #[get("/{uuid}")]
-pub async fn get(
+pub async fn res(
     req: HttpRequest,
     path: web::Path<(Uuid,)>,
     data: web::Data<Data>,
 ) -> Result<HttpResponse, Error> {
     let headers = req.headers();
 
-    let user_uuid = path.into_inner().0;
+    let uuid = path.into_inner().0;
 
     let auth_header = get_auth_header(headers)?;
 
     let mut conn = data.pool.get().await?;
 
-    let uuid = check_access_token(auth_header, &mut conn).await?;
+    check_access_token(auth_header, &mut conn).await?;
 
-    global_checks(&data, uuid).await?;
+    if let Ok(cache_hit) = data.get_cache_key(uuid.to_string()).await {
+        return Ok(HttpResponse::Ok()
+            .content_type("application/json")
+            .body(cache_hit));
+    }
 
-    let user = User::fetch_one(&data, user_uuid).await?;
+    let user = User::fetch_one(&mut conn, uuid).await?;
+
+    data.set_cache_key(uuid.to_string(), user.clone(), 1800)
+        .await?;
 
     Ok(HttpResponse::Ok().json(user))
 }

src/api/versions.rs

@@ -1,4 +1,3 @@
-//! `/api/v1/versions` Returns info about api versions
 use actix_web::{HttpResponse, Responder, get};
 use serde::Serialize;
 
@@ -11,21 +10,8 @@ struct Response {
 #[derive(Serialize)]
 struct UnstableFeatures;
 
-/// `GET /api/versions` Returns info about api versions.
-///
-/// requires auth: no
-///
-/// ### Response Example
-/// ```
-/// json!({
-///     "unstable_features": {},
-///     "versions": [
-///         "1"
-///     ]
-/// });
-/// ```
 #[get("/versions")]
-pub async fn get() -> impl Responder {
+pub async fn res() -> impl Responder {
     let response = Response {
         unstable_features: UnstableFeatures,
         // TODO: Find a way to dynamically update this possibly?

src/config.rs

@@ -1,6 +1,5 @@
 use crate::error::Error;
 use bunny_api_tokio::edge_storage::Endpoint;
-use lettre::transport::smtp::authentication::Credentials;
 use log::debug;
 use serde::Deserialize;
 use tokio::fs::read_to_string;
@@ -11,9 +10,7 @@ pub struct ConfigBuilder {
     database: Database,
     cache_database: CacheDatabase,
     web: WebBuilder,
-    instance: Option<InstanceBuilder>,
+    bunny: Option<BunnyBuilder>,
-    bunny: BunnyBuilder,
-    mail: Mail,
 }
 
 #[derive(Debug, Deserialize, Clone)]
@@ -38,18 +35,10 @@ pub struct CacheDatabase {
 struct WebBuilder {
     ip: Option<String>,
     port: Option<u16>,
-    frontend_url: Url,
+    url: Url,
-    backend_url: Option<Url>,
     _ssl: Option<bool>,
 }
 
-#[derive(Debug, Deserialize)]
-struct InstanceBuilder {
-    name: Option<String>,
-    registration: Option<bool>,
-    require_email_verification: Option<bool>,
-}
-
 #[derive(Debug, Deserialize)]
 struct BunnyBuilder {
     api_key: String,
@@ -58,20 +47,6 @@ struct BunnyBuilder {
     cdn_url: Url,
 }
 
-#[derive(Debug, Deserialize, Clone)]
-pub struct Mail {
-    pub smtp: Smtp,
-    pub address: String,
-    pub tls: String,
-}
-
-#[derive(Debug, Deserialize, Clone)]
-pub struct Smtp {
-    pub server: String,
-    username: String,
-    password: String,
-}
-
 impl ConfigBuilder {
     pub async fn load(path: String) -> Result<Self, Error> {
         debug!("loading config from: {}", path);
@@ -86,15 +61,13 @@ impl ConfigBuilder {
         let web = Web {
                 ip: self.web.ip.unwrap_or(String::from("0.0.0.0")),
                 port: self.web.port.unwrap_or(8080),
-            frontend_url: self.web.frontend_url.clone(),
+                url: self.web.url
-            backend_url: self
-                .web
-                .backend_url
-                .or_else(|| self.web.frontend_url.join("/api").ok())
-                .unwrap(),
             };
 
-        let endpoint = match &*self.bunny.endpoint {
+        let bunny;
+
+        if let Some(bunny_builder) = self.bunny {
+            let endpoint = match &*bunny_builder.endpoint {
                 "Frankfurt" => Endpoint::Frankfurt,
                 "London" => Endpoint::London,
                 "New York" => Endpoint::NewYork,
@@ -107,33 +80,21 @@ impl ConfigBuilder {
                 url => Endpoint::Custom(url.to_string()),
             };
 
-        let bunny = Bunny {
+            bunny = Some(Bunny {
-            api_key: self.bunny.api_key,
+                api_key: bunny_builder.api_key,
                 endpoint,
-            storage_zone: self.bunny.storage_zone,
+                storage_zone: bunny_builder.storage_zone,
-            cdn_url: self.bunny.cdn_url,
+                cdn_url: bunny_builder.cdn_url,
-        };
+            });
-
+        } else {
-        let instance = match self.instance {
+            bunny = None;
-            Some(instance) => Instance {
+        }
-                name: instance.name.unwrap_or("Gorb".to_string()),
-                registration: instance.registration.unwrap_or(true),
-                require_email_verification: instance.require_email_verification.unwrap_or(false),
-            },
-            None => Instance {
-                name: "Gorb".to_string(),
-                registration: true,
-                require_email_verification: false,
-            },
-        };
 
         Config {
             database: self.database,
             cache_database: self.cache_database,
             web,
-            instance,
             bunny,
-            mail: self.mail,
         }
     }
 }
@@ -143,24 +104,14 @@ pub struct Config {
     pub database: Database,
     pub cache_database: CacheDatabase,
     pub web: Web,
-    pub instance: Instance,
+    pub bunny: Option<Bunny>,
-    pub bunny: Bunny,
-    pub mail: Mail,
 }
 
 #[derive(Debug, Clone)]
 pub struct Web {
     pub ip: String,
     pub port: u16,
-    pub frontend_url: Url,
+    pub url: Url,
-    pub backend_url: Url,
-}
-
-#[derive(Debug, Clone)]
-pub struct Instance {
-    pub name: String,
-    pub registration: bool,
-    pub require_email_verification: bool,
 }
 
 #[derive(Debug, Clone)]
@@ -222,9 +173,3 @@ impl CacheDatabase {
         url
     }
 }
-
-impl Smtp {
-    pub fn credentials(&self) -> Credentials {
-        Credentials::new(self.username.clone(), self.password.clone())
-    }
-}

src/error.rs

@@ -12,9 +12,6 @@ use bunny_api_tokio::error::Error as BunnyError;
 use deadpool::managed::{BuildError, PoolError};
 use diesel::{ConnectionError, result::Error as DieselError};
 use diesel_async::pooled_connection::PoolError as DieselPoolError;
-use lettre::{
-    address::AddressError, error::Error as EmailError, transport::smtp::Error as SmtpError,
-};
 use log::{debug, error};
 use redis::RedisError;
 use serde::Serialize;
@@ -55,26 +52,14 @@ pub enum Error {
     UrlParseError(#[from] url::ParseError),
     #[error(transparent)]
     PayloadError(#[from] PayloadError),
-    #[error(transparent)]
-    WsClosed(#[from] actix_ws::Closed),
-    #[error(transparent)]
-    EmailError(#[from] EmailError),
-    #[error(transparent)]
-    SmtpError(#[from] SmtpError),
-    #[error(transparent)]
-    SmtpAddressError(#[from] AddressError),
     #[error("{0}")]
     PasswordHashError(String),
     #[error("{0}")]
+    PathError(String),
+    #[error("{0}")]
     BadRequest(String),
     #[error("{0}")]
     Unauthorized(String),
-    #[error("{0}")]
-    Forbidden(String),
-    #[error("{0}")]
-    TooManyRequests(String),
-    #[error("{0}")]
-    InternalServerError(String),
 }
 
 impl ResponseError for Error {
@@ -93,8 +78,6 @@ impl ResponseError for Error {
             Error::BunnyError(BunnyError::NotFound(_)) => StatusCode::NOT_FOUND,
             Error::BadRequest(_) => StatusCode::BAD_REQUEST,
             Error::Unauthorized(_) => StatusCode::UNAUTHORIZED,
-            Error::Forbidden(_) => StatusCode::FORBIDDEN,
-            Error::TooManyRequests(_) => StatusCode::TOO_MANY_REQUESTS,
             _ => StatusCode::INTERNAL_SERVER_ERROR,
         }
     }

src/main.rs

@@ -1,12 +1,13 @@
 use actix_cors::Cors;
+use actix_files::Files;
 use actix_web::{App, HttpServer, web};
 use argon2::Argon2;
 use clap::Parser;
 use diesel_async::pooled_connection::AsyncDieselConnectionManager;
 use diesel_async::pooled_connection::deadpool::Pool;
 use error::Error;
-use objects::MailClient;
 use simple_logger::SimpleLogger;
+use structs::Storage;
 use std::time::SystemTime;
 mod config;
 use config::{Config, ConfigBuilder};
@@ -19,15 +20,17 @@ type Conn =
 
 mod api;
 pub mod error;
-pub mod objects;
 pub mod schema;
+pub mod structs;
 pub mod utils;
 
-#[derive(Parser, Debug)]
+#[derive(Parser, Debug, Clone)]
 #[command(version, about, long_about = None)]
 struct Args {
     #[arg(short, long, default_value_t = String::from("/etc/gorb/config.toml"))]
     config: String,
+    #[arg(short, long, default_value_t = String::from("/var/lib/gorb/"))]
+    data_dir: String,
 }
 
 #[derive(Clone)]
@@ -40,8 +43,7 @@ pub struct Data {
     pub config: Config,
     pub argon2: Argon2<'static>,
     pub start_time: SystemTime,
-    pub bunny_storage: bunny_api_tokio::EdgeStorageClient,
+    pub storage: Storage,
-    pub mail_client: MailClient,
 }
 
 #[tokio::main]
@@ -65,18 +67,7 @@ async fn main() -> Result<(), Error> {
 
     let cache_pool = redis::Client::open(config.cache_database.url())?;
 
-    let bunny = config.bunny.clone();
+    let storage = Storage::new(config.clone(), args.data_dir.clone()).await?;
-
-    let bunny_storage = bunny_api_tokio::EdgeStorageClient::new(bunny.api_key, bunny.endpoint, bunny.storage_zone).await?;
-
-    let mail = config.mail.clone();
-
-    let mail_client = MailClient::new(
-        mail.smtp.credentials(),
-        mail.smtp.server,
-        mail.address,
-        mail.tls,
-    )?;
 
     let database_url = config.database.url();
 
@@ -117,10 +108,11 @@ async fn main() -> Result<(), Error> {
         // TODO: Possibly implement "pepper" into this (thinking it could generate one if it doesnt exist and store it on disk)
         argon2: Argon2::default(),
         start_time: SystemTime::now(),
-        bunny_storage,
+        storage,
-        mail_client,
     };
 
+    let data_dir = args.data_dir.clone();
+
     HttpServer::new(move || {
         // Set CORS headers
         let cors = Cors::default()
@@ -150,7 +142,8 @@ async fn main() -> Result<(), Error> {
         App::new()
             .app_data(web::Data::new(data.clone()))
             .wrap(cors)
-            .service(api::web(data.config.web.backend_url.path()))
+            .service(Files::new("/api/assets", &data_dir))
+            .service(api::web())
     })
     .bind((web.ip, web.port))?
     .run()

src/objects/channel.rs

@@ -1,384 +0,0 @@
-use diesel::{
-    ExpressionMethods, Insertable, QueryDsl, Queryable, Selectable, SelectableHelper, delete,
-    insert_into, update,
-};
-use diesel_async::{RunQueryDsl, pooled_connection::AsyncDieselConnectionManager};
-use serde::{Deserialize, Serialize};
-use uuid::Uuid;
-
-use crate::{
-    Conn, Data,
-    error::Error,
-    schema::{channel_permissions, channels, messages},
-    utils::{CHANNEL_REGEX, order_by_is_above},
-};
-
-use super::{HasIsAbove, HasUuid, Message, load_or_empty, message::MessageBuilder};
-
-#[derive(Queryable, Selectable, Insertable, Clone, Debug)]
-#[diesel(table_name = channels)]
-#[diesel(check_for_backend(diesel::pg::Pg))]
-struct ChannelBuilder {
-    uuid: Uuid,
-    guild_uuid: Uuid,
-    name: String,
-    description: Option<String>,
-    is_above: Option<Uuid>,
-}
-
-impl ChannelBuilder {
-    async fn build(self, conn: &mut Conn) -> Result<Channel, Error> {
-        use self::channel_permissions::dsl::*;
-        let channel_permission: Vec<ChannelPermission> = load_or_empty(
-            channel_permissions
-                .filter(channel_uuid.eq(self.uuid))
-                .select(ChannelPermission::as_select())
-                .load(conn)
-                .await,
-        )?;
-
-        Ok(Channel {
-            uuid: self.uuid,
-            guild_uuid: self.guild_uuid,
-            name: self.name,
-            description: self.description,
-            is_above: self.is_above,
-            permissions: channel_permission,
-        })
-    }
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug)]
-pub struct Channel {
-    pub uuid: Uuid,
-    pub guild_uuid: Uuid,
-    name: String,
-    description: Option<String>,
-    pub is_above: Option<Uuid>,
-    pub permissions: Vec<ChannelPermission>,
-}
-
-#[derive(Serialize, Deserialize, Clone, Queryable, Selectable, Debug)]
-#[diesel(table_name = channel_permissions)]
-#[diesel(check_for_backend(diesel::pg::Pg))]
-pub struct ChannelPermission {
-    pub role_uuid: Uuid,
-    pub permissions: i64,
-}
-
-impl HasUuid for Channel {
-    fn uuid(&self) -> &Uuid {
-        self.uuid.as_ref()
-    }
-}
-
-impl HasIsAbove for Channel {
-    fn is_above(&self) -> Option<&Uuid> {
-        self.is_above.as_ref()
-    }
-}
-
-impl Channel {
-    pub async fn fetch_all(
-        pool: &deadpool::managed::Pool<
-            AsyncDieselConnectionManager<diesel_async::AsyncPgConnection>,
-            Conn,
-        >,
-        guild_uuid: Uuid,
-    ) -> Result<Vec<Self>, Error> {
-        let mut conn = pool.get().await?;
-
-        use channels::dsl;
-        let channel_builders: Vec<ChannelBuilder> = load_or_empty(
-            dsl::channels
-                .filter(dsl::guild_uuid.eq(guild_uuid))
-                .select(ChannelBuilder::as_select())
-                .load(&mut conn)
-                .await,
-        )?;
-
-        let channel_futures = channel_builders.iter().map(async move |c| {
-            let mut conn = pool.get().await?;
-            c.clone().build(&mut conn).await
-        });
-
-        futures::future::try_join_all(channel_futures).await
-    }
-
-    pub async fn fetch_one(data: &Data, channel_uuid: Uuid) -> Result<Self, Error> {
-        if let Ok(cache_hit) = data.get_cache_key(channel_uuid.to_string()).await {
-            return Ok(serde_json::from_str(&cache_hit)?);
-        }
-
-        let mut conn = data.pool.get().await?;
-
-        use channels::dsl;
-        let channel_builder: ChannelBuilder = dsl::channels
-            .filter(dsl::uuid.eq(channel_uuid))
-            .select(ChannelBuilder::as_select())
-            .get_result(&mut conn)
-            .await?;
-
-        let channel = channel_builder.build(&mut conn).await?;
-
-        data.set_cache_key(channel_uuid.to_string(), channel.clone(), 60)
-            .await?;
-
-        Ok(channel)
-    }
-
-    pub async fn new(
-        data: actix_web::web::Data<Data>,
-        guild_uuid: Uuid,
-        name: String,
-        description: Option<String>,
-    ) -> Result<Self, Error> {
-        if !CHANNEL_REGEX.is_match(&name) {
-            return Err(Error::BadRequest("Channel name is invalid".to_string()));
-        }
-
-        let mut conn = data.pool.get().await?;
-
-        let channel_uuid = Uuid::now_v7();
-
-        let channels = Self::fetch_all(&data.pool, guild_uuid).await?;
-
-        let channels_ordered = order_by_is_above(channels).await?;
-
-        let last_channel = channels_ordered.last();
-
-        let new_channel = ChannelBuilder {
-            uuid: channel_uuid,
-            guild_uuid,
-            name: name.clone(),
-            description: description.clone(),
-            is_above: None,
-        };
-
-        insert_into(channels::table)
-            .values(new_channel.clone())
-            .execute(&mut conn)
-            .await?;
-
-        if let Some(old_last_channel) = last_channel {
-            use channels::dsl;
-            update(channels::table)
-                .filter(dsl::uuid.eq(old_last_channel.uuid))
-                .set(dsl::is_above.eq(new_channel.uuid))
-                .execute(&mut conn)
-                .await?;
-        }
-
-        // returns different object because there's no reason to build the channelbuilder (wastes 1 database request)
-        let channel = Self {
-            uuid: channel_uuid,
-            guild_uuid,
-            name,
-            description,
-            is_above: None,
-            permissions: vec![],
-        };
-
-        data.set_cache_key(channel_uuid.to_string(), channel.clone(), 1800)
-            .await?;
-
-        if data
-            .get_cache_key(format!("{}_channels", guild_uuid))
-            .await
-            .is_ok()
-        {
-            data.del_cache_key(format!("{}_channels", guild_uuid))
-                .await?;
-        }
-
-        Ok(channel)
-    }
-
-    pub async fn delete(self, data: &Data) -> Result<(), Error> {
-        let mut conn = data.pool.get().await?;
-
-        use channels::dsl;
-        match update(channels::table)
-            .filter(dsl::is_above.eq(self.uuid))
-            .set(dsl::is_above.eq(None::<Uuid>))
-            .execute(&mut conn)
-            .await
-        {
-            Ok(r) => Ok(r),
-            Err(diesel::result::Error::NotFound) => Ok(0),
-            Err(e) => Err(e),
-        }?;
-
-        delete(channels::table)
-            .filter(dsl::uuid.eq(self.uuid))
-            .execute(&mut conn)
-            .await?;
-
-        match update(channels::table)
-            .filter(dsl::is_above.eq(self.uuid))
-            .set(dsl::is_above.eq(self.is_above))
-            .execute(&mut conn)
-            .await
-        {
-            Ok(r) => Ok(r),
-            Err(diesel::result::Error::NotFound) => Ok(0),
-            Err(e) => Err(e),
-        }?;
-
-        if data.get_cache_key(self.uuid.to_string()).await.is_ok() {
-            data.del_cache_key(self.uuid.to_string()).await?;
-        }
-
-        if data
-            .get_cache_key(format!("{}_channels", self.guild_uuid))
-            .await
-            .is_ok()
-        {
-            data.del_cache_key(format!("{}_channels", self.guild_uuid))
-                .await?;
-        }
-
-        Ok(())
-    }
-
-    pub async fn fetch_messages(
-        &self,
-        data: &Data,
-        amount: i64,
-        offset: i64,
-    ) -> Result<Vec<Message>, Error> {
-        let mut conn = data.pool.get().await?;
-
-        use messages::dsl;
-        let messages: Vec<MessageBuilder> = load_or_empty(
-            dsl::messages
-                .filter(dsl::channel_uuid.eq(self.uuid))
-                .select(MessageBuilder::as_select())
-                .order(dsl::uuid.desc())
-                .limit(amount)
-                .offset(offset)
-                .load(&mut conn)
-                .await,
-        )?;
-
-        let message_futures = messages.iter().map(async move |b| b.build(data).await);
-
-        futures::future::try_join_all(message_futures).await
-    }
-
-    pub async fn new_message(
-        &self,
-        data: &Data,
-        user_uuid: Uuid,
-        message: String,
-    ) -> Result<Message, Error> {
-        let message_uuid = Uuid::now_v7();
-
-        let message = MessageBuilder {
-            uuid: message_uuid,
-            channel_uuid: self.uuid,
-            user_uuid,
-            message,
-        };
-
-        let mut conn = data.pool.get().await?;
-
-        insert_into(messages::table)
-            .values(message.clone())
-            .execute(&mut conn)
-            .await?;
-
-        message.build(data).await
-    }
-
-    pub async fn set_name(&mut self, data: &Data, new_name: String) -> Result<(), Error> {
-        if !CHANNEL_REGEX.is_match(&new_name) {
-            return Err(Error::BadRequest("Channel name is invalid".to_string()));
-        }
-
-        let mut conn = data.pool.get().await?;
-
-        use channels::dsl;
-        update(channels::table)
-            .filter(dsl::uuid.eq(self.uuid))
-            .set(dsl::name.eq(&new_name))
-            .execute(&mut conn)
-            .await?;
-
-        self.name = new_name;
-
-        Ok(())
-    }
-
-    pub async fn set_description(
-        &mut self,
-        data: &Data,
-        new_description: String,
-    ) -> Result<(), Error> {
-        let mut conn = data.pool.get().await?;
-
-        use channels::dsl;
-        update(channels::table)
-            .filter(dsl::uuid.eq(self.uuid))
-            .set(dsl::description.eq(&new_description))
-            .execute(&mut conn)
-            .await?;
-
-        self.description = Some(new_description);
-
-        Ok(())
-    }
-
-    pub async fn move_channel(&mut self, data: &Data, new_is_above: Uuid) -> Result<(), Error> {
-        let mut conn = data.pool.get().await?;
-
-        use channels::dsl;
-        let old_above_uuid: Option<Uuid> = match dsl::channels
-            .filter(dsl::is_above.eq(self.uuid))
-            .select(dsl::uuid)
-            .get_result(&mut conn)
-            .await
-        {
-            Ok(r) => Ok(Some(r)),
-            Err(diesel::result::Error::NotFound) => Ok(None),
-            Err(e) => Err(e),
-        }?;
-
-        if let Some(uuid) = old_above_uuid {
-            update(channels::table)
-                .filter(dsl::uuid.eq(uuid))
-                .set(dsl::is_above.eq(None::<Uuid>))
-                .execute(&mut conn)
-                .await?;
-        }
-
-        match update(channels::table)
-            .filter(dsl::is_above.eq(new_is_above))
-            .set(dsl::is_above.eq(self.uuid))
-            .execute(&mut conn)
-            .await
-        {
-            Ok(r) => Ok(r),
-            Err(diesel::result::Error::NotFound) => Ok(0),
-            Err(e) => Err(e),
-        }?;
-
-        update(channels::table)
-            .filter(dsl::uuid.eq(self.uuid))
-            .set(dsl::is_above.eq(new_is_above))
-            .execute(&mut conn)
-            .await?;
-
-        if let Some(uuid) = old_above_uuid {
-            update(channels::table)
-                .filter(dsl::uuid.eq(uuid))
-                .set(dsl::is_above.eq(self.is_above))
-                .execute(&mut conn)
-                .await?;
-        }
-
-        self.is_above = Some(new_is_above);
-
-        Ok(())
-    }
-}

src/objects/email_token.rs

@@ -1,61 +0,0 @@
-use chrono::Utc;
-use lettre::message::MultiPart;
-use serde::{Deserialize, Serialize};
-use uuid::Uuid;
-
-use crate::{Data, error::Error, utils::generate_token};
-
-use super::Me;
-
-#[derive(Serialize, Deserialize)]
-pub struct EmailToken {
-    user_uuid: Uuid,
-    pub token: String,
-    pub created_at: chrono::DateTime<Utc>,
-}
-
-impl EmailToken {
-    pub async fn get(data: &Data, user_uuid: Uuid) -> Result<EmailToken, Error> {
-        let email_token = serde_json::from_str(&data.get_cache_key(format!("{}_email_verify", user_uuid)).await?)?;
-
-        Ok(email_token)
-    }
-
-    #[allow(clippy::new_ret_no_self)]
-    pub async fn new(data: &Data, me: Me) -> Result<(), Error> {
-        let token = generate_token::<32>()?;
-
-        let email_token = EmailToken {
-            user_uuid: me.uuid,
-            token: token.clone(),
-            // TODO: Check if this can be replaced with something built into valkey
-            created_at: Utc::now()
-        };
-
-        data.set_cache_key(format!("{}_email_verify", me.uuid), email_token,  86400).await?;
-
-        let mut verify_endpoint = data.config.web.frontend_url.join("verify-email")?;
-
-        verify_endpoint.set_query(Some(&format!("token={}", token)));
-
-        let email = data
-            .mail_client
-            .message_builder()
-            .to(me.email.parse()?)
-            .subject(format!("{} E-mail Verification", data.config.instance.name))
-            .multipart(MultiPart::alternative_plain_html(
-                format!("Verify your {} account\n\nHello, {}!\nThanks for creating a new account on Gorb.\nThe final step to create your account is to verify your email address by visiting the page, within 24 hours.\n\n{}\n\nIf you didn't ask to verify this address, you can safely ignore this email\n\nThanks, The gorb team.", data.config.instance.name, me.username, verify_endpoint), 
-                format!(r#"<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><style>:root{{--header-text-colour: #ffffff;--footer-text-colour: #7f7f7f;--button-text-colour: #170e08;--text-colour: #170e08;--background-colour: #fbf6f2;--primary-colour: #df5f0b;--secondary-colour: #e8ac84;--accent-colour: #e68b4e;}}@media (prefers-color-scheme: dark){{:root{{--header-text-colour: #ffffff;--footer-text-colour: #585858;--button-text-colour: #ffffff;--text-colour: #f7eee8;--background-colour: #0c0704;--primary-colour: #f4741f;--secondary-colour: #7c4018;--accent-colour: #b35719;}}}}@media (max-width: 600px){{.container{{width: 100%;}}}}body{{font-family: Arial, sans-serif;align-content: center;text-align: center;margin: 0;padding: 0;background-color: var(--background-colour);color: var(--text-colour);width: 100%;max-width: 600px;margin: 0 auto;border-radius: 5px;}}.header{{background-color: var(--primary-colour);color: var(--header-text-colour);padding: 20px;}}.verify-button{{background-color: var(--accent-colour);color: var(--button-text-colour);padding: 12px 30px;margin: 16px;font-size: 20px;transition: background-color 0.3s;cursor: pointer;border: none;border-radius: 14px;text-decoration: none;display: inline-block;}}.verify-button:hover{{background-color: var(--secondary-colour);}}.content{{padding: 20px 30px;}}.footer{{padding: 10px;font-size: 12px;color: var(--footer-text-colour);}}</style></head><body><div class="container"><div class="header"><h1>Verify your {} Account</h1></div><div class="content"><h2>Hello, {}!</h2><p>Thanks for creating a new account on Gorb.</p><p>The final step to create your account is to verify your email address by clicking the button below, within 24 hours.</p><a href="{}" class="verify-button">VERIFY ACCOUNT</a><p>If you didn't ask to verify this address, you can safely ignore this email.</p><div class="footer"><p>Thanks<br>The gorb team.</p></div></div></div></body></html>"#, data.config.instance.name, me.username, verify_endpoint)
-            ))?;
-
-        data.mail_client.send_mail(email).await?;
-
-        Ok(())
-    }
-
-    pub async fn delete(&self, data: &Data) -> Result<(), Error> {
-        data.del_cache_key(format!("{}_email_verify", self.user_uuid)).await?;
-
-        Ok(())
-    }
-}

src/objects/guild.rs

@@ -1,222 +0,0 @@
-use actix_web::web::BytesMut;
-use diesel::{
-    ExpressionMethods, Insertable, QueryDsl, Queryable, Selectable, SelectableHelper, insert_into,
-    update,
-};
-use diesel_async::{RunQueryDsl, pooled_connection::AsyncDieselConnectionManager};
-use serde::Serialize;
-use tokio::task;
-use url::Url;
-use uuid::Uuid;
-
-use crate::{
-    Conn,
-    error::Error,
-    schema::{guild_members, guilds, invites},
-    utils::image_check,
-};
-
-use super::{Invite, Member, Role, load_or_empty, member::MemberBuilder};
-
-#[derive(Serialize, Queryable, Selectable, Insertable, Clone)]
-#[diesel(table_name = guilds)]
-#[diesel(check_for_backend(diesel::pg::Pg))]
-pub struct GuildBuilder {
-    uuid: Uuid,
-    name: String,
-    description: Option<String>,
-    icon: Option<String>,
-}
-
-impl GuildBuilder {
-    pub async fn build(self, conn: &mut Conn) -> Result<Guild, Error> {
-        let member_count = Member::count(conn, self.uuid).await?;
-
-        let roles = Role::fetch_all(conn, self.uuid).await?;
-
-        Ok(Guild {
-            uuid: self.uuid,
-            name: self.name,
-            description: self.description,
-            icon: self.icon.and_then(|i| i.parse().ok()),
-            roles,
-            member_count,
-        })
-    }
-}
-
-#[derive(Serialize)]
-pub struct Guild {
-    pub uuid: Uuid,
-    name: String,
-    description: Option<String>,
-    icon: Option<Url>,
-    pub roles: Vec<Role>,
-    member_count: i64,
-}
-
-impl Guild {
-    pub async fn fetch_one(conn: &mut Conn, guild_uuid: Uuid) -> Result<Self, Error> {
-        use guilds::dsl;
-        let guild_builder: GuildBuilder = dsl::guilds
-            .filter(dsl::uuid.eq(guild_uuid))
-            .select(GuildBuilder::as_select())
-            .get_result(conn)
-            .await?;
-
-        guild_builder.build(conn).await
-    }
-
-    pub async fn fetch_amount(
-        pool: &deadpool::managed::Pool<
-            AsyncDieselConnectionManager<diesel_async::AsyncPgConnection>,
-            Conn,
-        >,
-        offset: i64,
-        amount: i64,
-    ) -> Result<Vec<Self>, Error> {
-        // Fetch guild data from database
-        let mut conn = pool.get().await?;
-
-        use guilds::dsl;
-        let guild_builders: Vec<GuildBuilder> = load_or_empty(
-            dsl::guilds
-                .select(GuildBuilder::as_select())
-                .order_by(dsl::uuid)
-                .offset(offset)
-                .limit(amount)
-                .load(&mut conn)
-                .await,
-        )?;
-
-        // Process each guild concurrently
-        let guild_futures = guild_builders.iter().map(async move |g| {
-            let mut conn = pool.get().await?;
-            g.clone().build(&mut conn).await
-        });
-
-        // Execute all futures concurrently and collect results
-        futures::future::try_join_all(guild_futures).await
-    }
-
-    pub async fn new(conn: &mut Conn, name: String, owner_uuid: Uuid) -> Result<Self, Error> {
-        let guild_uuid = Uuid::now_v7();
-
-        let guild_builder = GuildBuilder {
-            uuid: guild_uuid,
-            name: name.clone(),
-            description: None,
-            icon: None,
-        };
-
-        insert_into(guilds::table)
-            .values(guild_builder)
-            .execute(conn)
-            .await?;
-
-        let member_uuid = Uuid::now_v7();
-
-        let member = MemberBuilder {
-            uuid: member_uuid,
-            nickname: None,
-            user_uuid: owner_uuid,
-            guild_uuid,
-            is_owner: true,
-        };
-
-        insert_into(guild_members::table)
-            .values(member)
-            .execute(conn)
-            .await?;
-
-        Ok(Guild {
-            uuid: guild_uuid,
-            name,
-            description: None,
-            icon: None,
-            roles: vec![],
-            member_count: 1,
-        })
-    }
-
-    pub async fn get_invites(&self, conn: &mut Conn) -> Result<Vec<Invite>, Error> {
-        use invites::dsl;
-        let invites = load_or_empty(
-            dsl::invites
-                .filter(dsl::guild_uuid.eq(self.uuid))
-                .select(Invite::as_select())
-                .load(conn)
-                .await,
-        )?;
-
-        Ok(invites)
-    }
-
-    pub async fn create_invite(
-        &self,
-        conn: &mut Conn,
-        user_uuid: Uuid,
-        custom_id: Option<String>,
-    ) -> Result<Invite, Error> {
-        let invite_id;
-
-        if let Some(id) = custom_id {
-            invite_id = id;
-            if invite_id.len() > 32 {
-                return Err(Error::BadRequest("MAX LENGTH".to_string()));
-            }
-        } else {
-            let charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
-
-            invite_id = random_string::generate(8, charset);
-        }
-
-        let invite = Invite {
-            id: invite_id,
-            user_uuid,
-            guild_uuid: self.uuid,
-        };
-
-        insert_into(invites::table)
-            .values(invite.clone())
-            .execute(conn)
-            .await?;
-
-        Ok(invite)
-    }
-
-    // FIXME: Horrible security
-    pub async fn set_icon(
-        &mut self,
-        bunny_storage: &bunny_api_tokio::EdgeStorageClient,
-        conn: &mut Conn,
-        cdn_url: Url,
-        icon: BytesMut,
-    ) -> Result<(), Error> {
-        let icon_clone = icon.clone();
-        let image_type = task::spawn_blocking(move || image_check(icon_clone)).await??;
-
-        if let Some(icon) = &self.icon {
-            let relative_url = icon.path().trim_start_matches('/');
-
-            bunny_storage.delete(relative_url).await?;
-        }
-
-        let path = format!("icons/{}/icon.{}", self.uuid, image_type);
-
-        bunny_storage.upload(path.clone(), icon.into()).await?;
-
-        let icon_url = cdn_url.join(&path)?;
-
-        use guilds::dsl;
-        update(guilds::table)
-            .filter(dsl::uuid.eq(self.uuid))
-            .set(dsl::icon.eq(icon_url.as_str()))
-            .execute(conn)
-            .await?;
-
-        self.icon = Some(icon_url);
-
-        Ok(())
-    }
-}

src/objects/invite.rs

@@ -1,30 +0,0 @@
-use diesel::{ExpressionMethods, Insertable, QueryDsl, Queryable, Selectable, SelectableHelper};
-use diesel_async::RunQueryDsl;
-use serde::Serialize;
-use uuid::Uuid;
-
-use crate::{Conn, error::Error, schema::invites};
-
-/// Server invite struct
-#[derive(Clone, Serialize, Queryable, Selectable, Insertable)]
-pub struct Invite {
-    /// case-sensitive alphanumeric string with a fixed length of 8 characters, can be up to 32 characters for custom invites
-    pub id: String,
-    /// User that created the invite
-    pub user_uuid: Uuid,
-    /// UUID of the guild that the invite belongs to
-    pub guild_uuid: Uuid,
-}
-
-impl Invite {
-    pub async fn fetch_one(conn: &mut Conn, invite_id: String) -> Result<Self, Error> {
-        use invites::dsl;
-        let invite: Invite = dsl::invites
-            .filter(dsl::id.eq(invite_id))
-            .select(Invite::as_select())
-            .get_result(conn)
-            .await?;
-
-        Ok(invite)
-    }
-}

src/objects/me.rs

@@ -1,231 +0,0 @@
-use actix_web::web::BytesMut;
-use diesel::{ExpressionMethods, QueryDsl, Queryable, Selectable, SelectableHelper, update};
-use diesel_async::RunQueryDsl;
-use serde::Serialize;
-use tokio::task;
-use url::Url;
-use uuid::Uuid;
-
-use crate::{
-    Conn, Data,
-    error::Error,
-    schema::{guild_members, guilds, users},
-    utils::{EMAIL_REGEX, USERNAME_REGEX, image_check},
-};
-
-use super::{Guild, guild::GuildBuilder, load_or_empty, member::MemberBuilder};
-
-#[derive(Serialize, Queryable, Selectable)]
-#[diesel(table_name = users)]
-#[diesel(check_for_backend(diesel::pg::Pg))]
-pub struct Me {
-    pub uuid: Uuid,
-    pub username: String,
-    pub display_name: Option<String>,
-    avatar: Option<String>,
-    pronouns: Option<String>,
-    about: Option<String>,
-    pub email: String,
-    pub email_verified: bool,
-}
-
-impl Me {
-    pub async fn get(conn: &mut Conn, user_uuid: Uuid) -> Result<Self, Error> {
-        use users::dsl;
-        let me: Me = dsl::users
-            .filter(dsl::uuid.eq(user_uuid))
-            .select(Me::as_select())
-            .get_result(conn)
-            .await?;
-
-        Ok(me)
-    }
-
-    pub async fn fetch_memberships(&self, conn: &mut Conn) -> Result<Vec<Guild>, Error> {
-        use guild_members::dsl;
-        let memberships: Vec<MemberBuilder> = load_or_empty(
-            dsl::guild_members
-                .filter(dsl::user_uuid.eq(self.uuid))
-                .select(MemberBuilder::as_select())
-                .load(conn)
-                .await,
-        )?;
-
-        let mut guilds: Vec<Guild> = vec![];
-
-        for membership in memberships {
-            use guilds::dsl;
-            guilds.push(
-                dsl::guilds
-                    .filter(dsl::uuid.eq(membership.guild_uuid))
-                    .select(GuildBuilder::as_select())
-                    .get_result(conn)
-                    .await?
-                    .build(conn)
-                    .await?,
-            )
-        }
-
-        Ok(guilds)
-    }
-
-    pub async fn set_avatar(
-        &mut self,
-        data: &Data,
-        cdn_url: Url,
-        avatar: BytesMut,
-    ) -> Result<(), Error> {
-        let avatar_clone = avatar.clone();
-        let image_type = task::spawn_blocking(move || image_check(avatar_clone)).await??;
-
-        let mut conn = data.pool.get().await?;
-
-        if let Some(avatar) = &self.avatar {
-            let avatar_url: Url = avatar.parse()?;
-
-            let relative_url = avatar_url.path().trim_start_matches('/');
-
-            data.bunny_storage.delete(relative_url).await?;
-        }
-
-        let path = format!("avatar/{}/avatar.{}", self.uuid, image_type);
-
-        data.bunny_storage
-            .upload(path.clone(), avatar.into())
-            .await?;
-
-        let avatar_url = cdn_url.join(&path)?;
-
-        use users::dsl;
-        update(users::table)
-            .filter(dsl::uuid.eq(self.uuid))
-            .set(dsl::avatar.eq(avatar_url.as_str()))
-            .execute(&mut conn)
-            .await?;
-
-        if data.get_cache_key(self.uuid.to_string()).await.is_ok() {
-            data.del_cache_key(self.uuid.to_string()).await?
-        }
-
-        self.avatar = Some(avatar_url.to_string());
-
-        Ok(())
-    }
-
-    pub async fn verify_email(&self, conn: &mut Conn) -> Result<(), Error> {
-        use users::dsl;
-        update(users::table)
-            .filter(dsl::uuid.eq(self.uuid))
-            .set(dsl::email_verified.eq(true))
-            .execute(conn)
-            .await?;
-
-        Ok(())
-    }
-
-    pub async fn set_username(&mut self, data: &Data, new_username: String) -> Result<(), Error> {
-        if !USERNAME_REGEX.is_match(&new_username) {
-            return Err(Error::BadRequest("Invalid username".to_string()));
-        }
-
-        let mut conn = data.pool.get().await?;
-
-        use users::dsl;
-        update(users::table)
-            .filter(dsl::uuid.eq(self.uuid))
-            .set(dsl::username.eq(new_username.as_str()))
-            .execute(&mut conn)
-            .await?;
-
-        if data.get_cache_key(self.uuid.to_string()).await.is_ok() {
-            data.del_cache_key(self.uuid.to_string()).await?
-        }
-
-        self.username = new_username;
-
-        Ok(())
-    }
-
-    pub async fn set_display_name(
-        &mut self,
-        data: &Data,
-        new_display_name: String,
-    ) -> Result<(), Error> {
-        let mut conn = data.pool.get().await?;
-
-        use users::dsl;
-        update(users::table)
-            .filter(dsl::uuid.eq(self.uuid))
-            .set(dsl::display_name.eq(new_display_name.as_str()))
-            .execute(&mut conn)
-            .await?;
-
-        if data.get_cache_key(self.uuid.to_string()).await.is_ok() {
-            data.del_cache_key(self.uuid.to_string()).await?
-        }
-
-        self.display_name = Some(new_display_name);
-
-        Ok(())
-    }
-
-    pub async fn set_email(&mut self, data: &Data, new_email: String) -> Result<(), Error> {
-        if !EMAIL_REGEX.is_match(&new_email) {
-            return Err(Error::BadRequest("Invalid username".to_string()));
-        }
-
-        let mut conn = data.pool.get().await?;
-
-        use users::dsl;
-        update(users::table)
-            .filter(dsl::uuid.eq(self.uuid))
-            .set((
-                dsl::email.eq(new_email.as_str()),
-                dsl::email_verified.eq(false),
-            ))
-            .execute(&mut conn)
-            .await?;
-
-        if data.get_cache_key(self.uuid.to_string()).await.is_ok() {
-            data.del_cache_key(self.uuid.to_string()).await?
-        }
-
-        self.email = new_email;
-
-        Ok(())
-    }
-
-    pub async fn set_pronouns(&mut self, data: &Data, new_pronouns: String) -> Result<(), Error> {
-        let mut conn = data.pool.get().await?;
-
-        use users::dsl;
-        update(users::table)
-            .filter(dsl::uuid.eq(self.uuid))
-            .set((dsl::pronouns.eq(new_pronouns.as_str()),))
-            .execute(&mut conn)
-            .await?;
-
-        if data.get_cache_key(self.uuid.to_string()).await.is_ok() {
-            data.del_cache_key(self.uuid.to_string()).await?
-        }
-
-        Ok(())
-    }
-
-    pub async fn set_about(&mut self, data: &Data, new_about: String) -> Result<(), Error> {
-        let mut conn = data.pool.get().await?;
-
-        use users::dsl;
-        update(users::table)
-            .filter(dsl::uuid.eq(self.uuid))
-            .set((dsl::about.eq(new_about.as_str()),))
-            .execute(&mut conn)
-            .await?;
-
-        if data.get_cache_key(self.uuid.to_string()).await.is_ok() {
-            data.del_cache_key(self.uuid.to_string()).await?
-        }
-
-        Ok(())
-    }
-}

src/objects/member.rs

@@ -1,141 +0,0 @@
-use diesel::{
-    ExpressionMethods, Insertable, QueryDsl, Queryable, Selectable, SelectableHelper, insert_into,
-};
-use diesel_async::RunQueryDsl;
-use serde::{Deserialize, Serialize};
-use uuid::Uuid;
-
-use crate::{error::Error, objects::{Permissions, Role}, schema::guild_members, Conn, Data};
-
-use super::{User, load_or_empty};
-
-#[derive(Serialize, Queryable, Selectable, Insertable)]
-#[diesel(table_name = guild_members)]
-#[diesel(check_for_backend(diesel::pg::Pg))]
-pub struct MemberBuilder {
-    pub uuid: Uuid,
-    pub nickname: Option<String>,
-    pub user_uuid: Uuid,
-    pub guild_uuid: Uuid,
-    pub is_owner: bool,
-}
-
-impl MemberBuilder {
-    pub async fn build(&self, data: &Data) -> Result<Member, Error> {
-        let user = User::fetch_one(data, self.user_uuid).await?;
-
-        Ok(Member {
-            uuid: self.uuid,
-            nickname: self.nickname.clone(),
-            user_uuid: self.user_uuid,
-            guild_uuid: self.guild_uuid,
-            is_owner: self.is_owner,
-            user,
-        })
-    }
-
-    pub async fn check_permission(&self, data: &Data, permission: Permissions) -> Result<(), Error> {
-        if !self.is_owner {
-            let roles = Role::fetch_from_member(&data, self.uuid).await?;
-            let allowed = roles.iter().any(|r| r.permissions & permission as i64 != 0);
-            if !allowed {
-                return Err(Error::Forbidden("Not allowed".to_string()))
-            }
-        }
-
-        Ok(())
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct Member {
-    pub uuid: Uuid,
-    pub nickname: Option<String>,
-    pub user_uuid: Uuid,
-    pub guild_uuid: Uuid,
-    pub is_owner: bool,
-    user: User,
-}
-
-impl Member {
-    pub async fn count(conn: &mut Conn, guild_uuid: Uuid) -> Result<i64, Error> {
-        use guild_members::dsl;
-        let count: i64 = dsl::guild_members
-            .filter(dsl::guild_uuid.eq(guild_uuid))
-            .count()
-            .get_result(conn)
-            .await?;
-
-        Ok(count)
-    }
-
-    pub async fn check_membership(
-        conn: &mut Conn,
-        user_uuid: Uuid,
-        guild_uuid: Uuid,
-    ) -> Result<MemberBuilder, Error> {
-        use guild_members::dsl;
-        let member_builder = dsl::guild_members
-            .filter(dsl::user_uuid.eq(user_uuid))
-            .filter(dsl::guild_uuid.eq(guild_uuid))
-            .select(MemberBuilder::as_select())
-            .get_result(conn)
-            .await?;
-
-        Ok(member_builder)
-    }
-
-    pub async fn fetch_one(data: &Data, user_uuid: Uuid, guild_uuid: Uuid) -> Result<Self, Error> {
-        let mut conn = data.pool.get().await?;
-
-        use guild_members::dsl;
-        let member: MemberBuilder = dsl::guild_members
-            .filter(dsl::user_uuid.eq(user_uuid))
-            .filter(dsl::guild_uuid.eq(guild_uuid))
-            .select(MemberBuilder::as_select())
-            .get_result(&mut conn)
-            .await?;
-
-        member.build(data).await
-    }
-
-    pub async fn fetch_all(data: &Data, guild_uuid: Uuid) -> Result<Vec<Self>, Error> {
-        let mut conn = data.pool.get().await?;
-
-        use guild_members::dsl;
-        let member_builders: Vec<MemberBuilder> = load_or_empty(
-            dsl::guild_members
-                .filter(dsl::guild_uuid.eq(guild_uuid))
-                .select(MemberBuilder::as_select())
-                .load(&mut conn)
-                .await,
-        )?;
-
-        let member_futures = member_builders
-            .iter()
-            .map(async move |m| m.build(data).await);
-
-        futures::future::try_join_all(member_futures).await
-    }
-
-    pub async fn new(data: &Data, user_uuid: Uuid, guild_uuid: Uuid) -> Result<Self, Error> {
-        let mut conn = data.pool.get().await?;
-
-        let member_uuid = Uuid::now_v7();
-
-        let member = MemberBuilder {
-            uuid: member_uuid,
-            guild_uuid,
-            user_uuid,
-            nickname: None,
-            is_owner: false,
-        };
-
-        insert_into(guild_members::table)
-            .values(&member)
-            .execute(&mut conn)
-            .await?;
-
-        member.build(data).await
-    }
-}

src/objects/message.rs

@@ -1,40 +0,0 @@
-use diesel::{Insertable, Queryable, Selectable};
-use serde::Serialize;
-use uuid::Uuid;
-
-use crate::{Data, error::Error, schema::messages};
-
-use super::User;
-
-#[derive(Clone, Queryable, Selectable, Insertable)]
-#[diesel(table_name = messages)]
-#[diesel(check_for_backend(diesel::pg::Pg))]
-pub struct MessageBuilder {
-    pub uuid: Uuid,
-    pub channel_uuid: Uuid,
-    pub user_uuid: Uuid,
-    pub message: String,
-}
-
-impl MessageBuilder {
-    pub async fn build(&self, data: &Data) -> Result<Message, Error> {
-        let user = User::fetch_one(data, self.user_uuid).await?;
-
-        Ok(Message {
-            uuid: self.uuid,
-            channel_uuid: self.channel_uuid,
-            user_uuid: self.user_uuid,
-            message: self.message.clone(),
-            user,
-        })
-    }
-}
-
-#[derive(Clone, Serialize)]
-pub struct Message {
-    uuid: Uuid,
-    channel_uuid: Uuid,
-    user_uuid: Uuid,
-    message: String,
-    user: User,
-}

src/objects/mod.rs

@@ -1,119 +0,0 @@
-use lettre::{
-    AsyncSmtpTransport, AsyncTransport, Message as Email, Tokio1Executor,
-    message::{Mailbox, MessageBuilder as EmailBuilder},
-    transport::smtp::authentication::Credentials,
-};
-use log::debug;
-use serde::Deserialize;
-use uuid::Uuid;
-
-mod channel;
-mod email_token;
-mod guild;
-mod invite;
-mod me;
-mod member;
-mod message;
-mod password_reset_token;
-mod role;
-mod user;
-
-pub use channel::Channel;
-pub use email_token::EmailToken;
-pub use guild::Guild;
-pub use invite::Invite;
-pub use me::Me;
-pub use member::Member;
-pub use message::Message;
-pub use password_reset_token::PasswordResetToken;
-pub use role::Role;
-pub use role::Permissions;
-pub use user::User;
-
-use crate::error::Error;
-
-pub trait HasUuid {
-    fn uuid(&self) -> &Uuid;
-}
-
-pub trait HasIsAbove {
-    fn is_above(&self) -> Option<&Uuid>;
-}
-
-fn load_or_empty<T>(
-    query_result: Result<Vec<T>, diesel::result::Error>,
-) -> Result<Vec<T>, diesel::result::Error> {
-    match query_result {
-        Ok(vec) => Ok(vec),
-        Err(diesel::result::Error::NotFound) => Ok(Vec::new()),
-        Err(e) => Err(e),
-    }
-}
-
-#[derive(PartialEq, Eq, Clone)]
-pub enum MailTls {
-    StartTls,
-    Tls,
-}
-
-impl From<String> for MailTls {
-    fn from(value: String) -> Self {
-        match &*value.to_lowercase() {
-            "starttls" => Self::StartTls,
-            _ => Self::Tls,
-        }
-    }
-}
-
-#[derive(Clone)]
-pub struct MailClient {
-    creds: Credentials,
-    smtp_server: String,
-    mbox: Mailbox,
-    tls: MailTls,
-}
-
-impl MailClient {
-    pub fn new<T: Into<MailTls>>(
-        creds: Credentials,
-        smtp_server: String,
-        mbox: String,
-        tls: T,
-    ) -> Result<Self, Error> {
-        Ok(Self {
-            creds,
-            smtp_server,
-            mbox: mbox.parse()?,
-            tls: tls.into(),
-        })
-    }
-
-    pub fn message_builder(&self) -> EmailBuilder {
-        Email::builder().from(self.mbox.clone())
-    }
-
-    pub async fn send_mail(&self, email: Email) -> Result<(), Error> {
-        let mailer: AsyncSmtpTransport<Tokio1Executor> = match self.tls {
-            MailTls::StartTls => {
-                AsyncSmtpTransport::<Tokio1Executor>::starttls_relay(&self.smtp_server)?
-                    .credentials(self.creds.clone())
-                    .build()
-            }
-            MailTls::Tls => AsyncSmtpTransport::<Tokio1Executor>::relay(&self.smtp_server)?
-                .credentials(self.creds.clone())
-                .build(),
-        };
-
-        let response = mailer.send(email).await?;
-
-        debug!("mail sending response: {:?}", response);
-
-        Ok(())
-    }
-}
-
-#[derive(Deserialize)]
-pub struct StartAmountQuery {
-    pub start: Option<i64>,
-    pub amount: Option<i64>,
-}

src/objects/password_reset_token.rs

@@ -1,146 +0,0 @@
-use argon2::{
-    PasswordHasher,
-    password_hash::{SaltString, rand_core::OsRng},
-};
-use chrono::Utc;
-use diesel::{
-    ExpressionMethods, QueryDsl, update,
-};
-use diesel_async::RunQueryDsl;
-use lettre::message::MultiPart;
-use serde::{Deserialize, Serialize};
-use uuid::Uuid;
-
-use crate::{
-    error::Error,
-    schema::users,
-    utils::{generate_token, global_checks, user_uuid_from_identifier, PASSWORD_REGEX},
-    Data
-};
-
-#[derive(Serialize, Deserialize)]
-pub struct PasswordResetToken {
-    user_uuid: Uuid,
-    pub token: String,
-    pub created_at: chrono::DateTime<Utc>,
-}
-
-impl PasswordResetToken {
-    pub async fn get(data: &Data, token: String) -> Result<PasswordResetToken, Error> {
-        let user_uuid: Uuid = serde_json::from_str(&data.get_cache_key(format!("{}", token)).await?)?;
-        let password_reset_token = serde_json::from_str(&data.get_cache_key(format!("{}_password_reset", user_uuid)).await?)?;
-
-        Ok(password_reset_token)
-    }
-
-    pub async fn get_with_identifier(
-        data: &Data,
-        identifier: String,
-    ) -> Result<PasswordResetToken, Error> {
-        let mut conn = data.pool.get().await?;
-
-        let user_uuid = user_uuid_from_identifier(&mut conn, &identifier).await?;
-
-        let password_reset_token = serde_json::from_str(&data.get_cache_key(format!("{}_password_reset", user_uuid)).await?)?;
-
-        Ok(password_reset_token)
-    }
-
-    #[allow(clippy::new_ret_no_self)]
-    pub async fn new(data: &Data, identifier: String) -> Result<(), Error> {
-        let token = generate_token::<32>()?;
-
-        let mut conn = data.pool.get().await?;
-
-        let user_uuid = user_uuid_from_identifier(&mut conn, &identifier).await?;
-
-        global_checks(data, user_uuid).await?;
-
-        use users::dsl as udsl;
-        let (username, email_address): (String, String) = udsl::users
-            .filter(udsl::uuid.eq(user_uuid))
-            .select((udsl::username, udsl::email))
-            .get_result(&mut conn)
-            .await?;
-
-        let password_reset_token = PasswordResetToken {
-            user_uuid,
-            token: token.clone(),
-            created_at: Utc::now(),
-        };
-
-        data.set_cache_key(format!("{}_password_reset", user_uuid), password_reset_token,  86400).await?;
-        data.set_cache_key(token.clone(), user_uuid, 86400).await?;
-
-        let mut reset_endpoint = data.config.web.frontend_url.join("reset-password")?;
-
-        reset_endpoint.set_query(Some(&format!("token={}", token)));
-
-        let email = data
-            .mail_client
-            .message_builder()
-            .to(email_address.parse()?)
-            .subject(format!("{} Password Reset", data.config.instance.name))
-            .multipart(MultiPart::alternative_plain_html(
-                format!("{} Password Reset\n\nHello, {}!\nSomeone requested a password reset for your Gorb account.\nClick the button below within 24 hours to reset your password.\n\n{}\n\nIf you didn't request a password reset, don't worry, your account is safe and you can safely ignore this email.\n\nThanks, The gorb team.", data.config.instance.name, username, reset_endpoint), 
-                format!(r#"<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><style>:root {{--header-text-colour: #ffffff;--footer-text-colour: #7f7f7f;--button-text-colour: #170e08;--text-colour: #170e08;--background-colour: #fbf6f2;--primary-colour: #df5f0b;--secondary-colour: #e8ac84;--accent-colour: #e68b4e;}}@media (prefers-color-scheme: dark) {{:root {{--header-text-colour: #ffffff;--footer-text-colour: #585858;--button-text-colour: #ffffff;--text-colour: #f7eee8;--background-colour: #0c0704;--primary-colour: #f4741f;--secondary-colour: #7c4018;--accent-colour: #b35719;}}}}@media (max-width: 600px) {{.container {{width: 100%;}}}}body {{font-family: Arial, sans-serif;align-content: center;text-align: center;margin: 0;padding: 0;background-color: var(--background-colour);color: var(--text-colour);width: 100%;max-width: 600px;margin: 0 auto;border-radius: 5px;}}.header {{background-color: var(--primary-colour);color: var(--header-text-colour);padding: 20px;}}.verify-button {{background-color: var(--accent-colour);color: var(--button-text-colour);padding: 12px 30px;margin: 16px;font-size: 20px;transition: background-color 0.3s;cursor: pointer;border: none;border-radius: 14px;text-decoration: none;display: inline-block;}}.verify-button:hover {{background-color: var(--secondary-colour);}}.content {{padding: 20px 30px;}}.footer {{padding: 10px;font-size: 12px;color: var(--footer-text-colour);}}</style></head><body><div class="container"><div class="header"><h1>{} Password Reset</h1></div><div class="content"><h2>Hello, {}!</h2><p>Someone requested a password reset for your Gorb account.</p><p>Click the button below within 24 hours to reset your password.</p><a href="{}" class="verify-button">RESET PASSWORD</a><p>If you didn't request a password reset, don't worry, your account is safe and you can safely ignore this email.</p><div class="footer"><p>Thanks<br>The gorb team.</p></div></div></div></body></html>"#, data.config.instance.name, username, reset_endpoint)
-            ))?;
-
-        data.mail_client.send_mail(email).await?;
-
-        Ok(())
-    }
-
-    pub async fn set_password(&self, data: &Data, password: String) -> Result<(), Error> {
-        if !PASSWORD_REGEX.is_match(&password) {
-            return Err(Error::BadRequest(
-                "Please provide a valid password".to_string(),
-            ));
-        }
-
-        let salt = SaltString::generate(&mut OsRng);
-
-        let hashed_password = data
-            .argon2
-            .hash_password(password.as_bytes(), &salt)
-            .map_err(|e| Error::PasswordHashError(e.to_string()))?;
-
-        let mut conn = data.pool.get().await?;
-
-        use users::dsl;
-        update(users::table)
-            .filter(dsl::uuid.eq(self.user_uuid))
-            .set(dsl::password.eq(hashed_password.to_string()))
-            .execute(&mut conn)
-            .await?;
-
-        let (username, email_address): (String, String) = dsl::users
-            .filter(dsl::uuid.eq(self.user_uuid))
-            .select((dsl::username, dsl::email))
-            .get_result(&mut conn)
-            .await?;
-
-        let login_page = data.config.web.frontend_url.join("login")?;
-
-        let email = data
-            .mail_client
-            .message_builder()
-            .to(email_address.parse()?)
-            .subject(format!("Your {} Password has been Reset", data.config.instance.name))
-            .multipart(MultiPart::alternative_plain_html(
-                format!("{} Password Reset Confirmation\n\nHello, {}!\nYour password has been successfully reset for your Gorb account.\nIf you did not initiate this change, please click the link below to reset your password <strong>immediately</strong>.\n\n{}\n\nThanks, The gorb team.", data.config.instance.name, username, login_page), 
-                format!(r#"<html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><style>:root {{--header-text-colour: #ffffff;--footer-text-colour: #7f7f7f;--button-text-colour: #170e08;--text-colour: #170e08;--background-colour: #fbf6f2;--primary-colour: #df5f0b;--secondary-colour: #e8ac84;--accent-colour: #e68b4e;}}@media (prefers-color-scheme: dark) {{:root {{--header-text-colour: #ffffff;--footer-text-colour: #585858;--button-text-colour: #ffffff;--text-colour: #f7eee8;--background-colour: #0c0704;--primary-colour: #f4741f;--secondary-colour: #7c4018;--accent-colour: #b35719;}}}}@media (max-width: 600px) {{.container {{width: 100%;}}}}body {{font-family: Arial, sans-serif;align-content: center;text-align: center;margin: 0;padding: 0;background-color: var(--background-colour);color: var(--text-colour);width: 100%;max-width: 600px;margin: 0 auto;border-radius: 5px;}}.header {{background-color: var(--primary-colour);color: var(--header-text-colour);padding: 20px;}}.verify-button {{background-color: var(--accent-colour);color: var(--button-text-colour);padding: 12px 30px;margin: 16px;font-size: 20px;transition: background-color 0.3s;cursor: pointer;border: none;border-radius: 14px;text-decoration: none;display: inline-block;}}.verify-button:hover {{background-color: var(--secondary-colour);}}.content {{padding: 20px 30px;}}.footer {{padding: 10px;font-size: 12px;color: var(--footer-text-colour);}}</style></head><body><div class="container"><div class="header"><h1>{} Password Reset Confirmation</h1></div><div class="content"><h2>Hello, {}!</h2><p>Your password has been successfully reset for your Gorb account.</p><p>If you did not initiate this change, please click the button below to reset your password <strong>immediately</strong>.</p><a href="{}" class="verify-button">RESET PASSWORD</a><div class="footer"><p>Thanks<br>The gorb team.</p></div></div></div></body></html>"#, data.config.instance.name, username, login_page)
-            ))?;
-
-        data.mail_client.send_mail(email).await?;
-
-        self.delete(&data).await
-    }
-
-    pub async fn delete(&self, data: &Data) -> Result<(), Error> {
-        data.del_cache_key(format!("{}_password_reset", &self.user_uuid)).await?;
-        data.del_cache_key(format!("{}", &self.token)).await?;
-
-        Ok(())
-    }
-}

src/objects/role.rs

@@ -1,186 +0,0 @@
-use diesel::{
-    ExpressionMethods, Insertable, QueryDsl, Queryable, Selectable, SelectableHelper, insert_into,
-    update,
-};
-use diesel_async::RunQueryDsl;
-use serde::{Deserialize, Serialize};
-use uuid::Uuid;
-
-use crate::{error::Error, schema::{role_members, roles}, utils::order_by_is_above, Conn, Data};
-
-use super::{HasIsAbove, HasUuid, load_or_empty};
-
-#[derive(Deserialize, Serialize, Clone, Queryable, Selectable, Insertable)]
-#[diesel(table_name = roles)]
-#[diesel(check_for_backend(diesel::pg::Pg))]
-pub struct Role {
-    uuid: Uuid,
-    guild_uuid: Uuid,
-    name: String,
-    color: i32,
-    is_above: Option<Uuid>,
-    pub permissions: i64,
-}
-
-#[derive(Serialize, Clone, Queryable, Selectable, Insertable)]
-#[diesel(table_name = role_members)]
-#[diesel(check_for_backend(diesel::pg::Pg))]
-pub struct RoleMember {
-    role_uuid: Uuid,
-    member_uuid: Uuid,
-}
-
-impl RoleMember {
-    async fn fetch_role(&self, conn: &mut Conn) -> Result<Role, Error> {
-        use roles::dsl;
-        let role: Role = dsl::roles
-            .filter(dsl::uuid.eq(self.role_uuid))
-            .select(Role::as_select())
-            .get_result(conn)
-            .await?;
-
-        Ok(role)
-    }
-}
-
-impl HasUuid for Role {
-    fn uuid(&self) -> &Uuid {
-        self.uuid.as_ref()
-    }
-}
-
-impl HasIsAbove for Role {
-    fn is_above(&self) -> Option<&Uuid> {
-        self.is_above.as_ref()
-    }
-}
-
-impl Role {
-    pub async fn fetch_all(conn: &mut Conn, guild_uuid: Uuid) -> Result<Vec<Self>, Error> {
-        use roles::dsl;
-        let roles: Vec<Role> = load_or_empty(
-            dsl::roles
-                .filter(dsl::guild_uuid.eq(guild_uuid))
-                .select(Role::as_select())
-                .load(conn)
-                .await,
-        )?;
-
-        Ok(roles)
-    }
-
-    pub async fn fetch_from_member(data: &Data, member_uuid: Uuid) -> Result<Vec<Self>, Error> {
-        if let Ok(roles) = data.get_cache_key(format!("{}_roles", member_uuid)).await {
-            return Ok(serde_json::from_str(&roles)?)
-        }
-
-        let mut conn = data.pool.get().await?;
-
-        use role_members::dsl;
-        let role_memberships: Vec<RoleMember> = load_or_empty(
-            dsl::role_members
-                .filter(dsl::member_uuid.eq(member_uuid))
-                .select(RoleMember::as_select())
-                .load(&mut conn)
-                .await,
-        )?;
-
-        let mut roles = vec![];
-
-        for membership in role_memberships {
-            roles.push(membership.fetch_role(&mut conn).await?);
-        }
-
-        data.set_cache_key(format!("{}_roles", member_uuid), roles.clone(), 300).await?;
-
-        Ok(roles)
-    }
-
-    pub async fn fetch_one(conn: &mut Conn, role_uuid: Uuid) -> Result<Self, Error> {
-        use roles::dsl;
-        let role: Role = dsl::roles
-            .filter(dsl::uuid.eq(role_uuid))
-            .select(Role::as_select())
-            .get_result(conn)
-            .await?;
-
-        Ok(role)
-    }
-
-    pub async fn fetch_permissions(&self) -> Vec<Permissions> {
-        Permissions::fetch_permissions(self.permissions.clone())
-    }
-
-    pub async fn new(conn: &mut Conn, guild_uuid: Uuid, name: String) -> Result<Self, Error> {
-        let role_uuid = Uuid::now_v7();
-
-        let roles = Self::fetch_all(conn, guild_uuid).await?;
-
-        let roles_ordered = order_by_is_above(roles).await?;
-
-        let last_role = roles_ordered.last();
-
-        let new_role = Role {
-            uuid: role_uuid,
-            guild_uuid,
-            name,
-            color: 16777215,
-            is_above: None,
-            permissions: 0,
-        };
-
-        insert_into(roles::table)
-            .values(new_role.clone())
-            .execute(conn)
-            .await?;
-
-        if let Some(old_last_role) = last_role {
-            use roles::dsl;
-            update(roles::table)
-                .filter(dsl::uuid.eq(old_last_role.uuid))
-                .set(dsl::is_above.eq(new_role.uuid))
-                .execute(conn)
-                .await?;
-        }
-
-        Ok(new_role)
-    }
-}
-
-#[derive(Clone, Copy, PartialEq, Eq)]
-pub enum Permissions {
-    SendMessage = 1,
-    CreateChannel = 2,
-    DeleteChannel = 4,
-    ManageChannel = 8,
-    CreateRole = 16,
-    DeleteRole = 32,
-    ManageRole = 64,
-    CreateInvite = 128,
-    ManageInvite = 256,
-    ManageServer = 512,
-    ManageMember = 1024,
-}
-
-impl Permissions {
-    pub fn fetch_permissions(permissions: i64) -> Vec<Self> {
-        let all_perms = vec![
-            Self::SendMessage,
-            Self::CreateChannel,
-            Self::DeleteChannel,
-            Self::ManageChannel,
-            Self::CreateRole,
-            Self::DeleteRole,
-            Self::ManageRole,
-            Self::CreateInvite,
-            Self::ManageInvite,
-            Self::ManageServer,
-            Self::ManageMember,
-        ];
-
-        all_perms
-            .into_iter()
-            .filter(|p| permissions & (*p as i64) != 0)
-            .collect()
-    }
-}

src/objects/user.rs

@@ -1,60 +0,0 @@
-use diesel::{ExpressionMethods, QueryDsl, Queryable, Selectable, SelectableHelper};
-use diesel_async::RunQueryDsl;
-use serde::{Deserialize, Serialize};
-use uuid::Uuid;
-
-use crate::{Conn, Data, error::Error, schema::users};
-
-use super::load_or_empty;
-
-#[derive(Deserialize, Serialize, Clone, Queryable, Selectable)]
-#[diesel(table_name = users)]
-#[diesel(check_for_backend(diesel::pg::Pg))]
-pub struct User {
-    uuid: Uuid,
-    username: String,
-    display_name: Option<String>,
-    avatar: Option<String>,
-    pronouns: Option<String>,
-    about: Option<String>,
-}
-
-impl User {
-    pub async fn fetch_one(data: &Data, user_uuid: Uuid) -> Result<Self, Error> {
-        let mut conn = data.pool.get().await?;
-
-        if let Ok(cache_hit) = data.get_cache_key(user_uuid.to_string()).await {
-            return Ok(serde_json::from_str(&cache_hit)?);
-        }
-
-        use users::dsl;
-        let user: User = dsl::users
-            .filter(dsl::uuid.eq(user_uuid))
-            .select(User::as_select())
-            .get_result(&mut conn)
-            .await?;
-
-        data.set_cache_key(user_uuid.to_string(), user.clone(), 1800)
-            .await?;
-
-        Ok(user)
-    }
-
-    pub async fn fetch_amount(
-        conn: &mut Conn,
-        offset: i64,
-        amount: i64,
-    ) -> Result<Vec<Self>, Error> {
-        use users::dsl;
-        let users: Vec<User> = load_or_empty(
-            dsl::users
-                .limit(amount)
-                .offset(offset)
-                .select(User::as_select())
-                .load(conn)
-                .await,
-        )?;
-
-        Ok(users)
-    }
-}

src/schema.rs

@@ -27,7 +27,6 @@ diesel::table! {
         name -> Varchar,
         #[max_length = 500]
         description -> Nullable<Varchar>,
-        is_above -> Nullable<Uuid>,
     }
 }
 
@@ -38,13 +37,13 @@ diesel::table! {
         user_uuid -> Uuid,
         #[max_length = 100]
         nickname -> Nullable<Varchar>,
-        is_owner -> Bool,
     }
 }
 
 diesel::table! {
     guilds (uuid) {
         uuid -> Uuid,
+        owner_uuid -> Uuid,
         #[max_length = 100]
         name -> Varchar,
         #[max_length = 300]
@@ -105,8 +104,8 @@ diesel::table! {
         #[max_length = 50]
         name -> Varchar,
         color -> Int4,
+        position -> Int4,
         permissions -> Int8,
-        is_above -> Nullable<Uuid>,
     }
 }
 
@@ -126,10 +125,6 @@ diesel::table! {
         deleted_at -> Nullable<Int8>,
         #[max_length = 100]
         avatar -> Nullable<Varchar>,
-        #[max_length = 32]
-        pronouns -> Nullable<Varchar>,
-        #[max_length = 200]
-        about -> Nullable<Varchar>,
     }
 }
 
@@ -139,6 +134,7 @@ diesel::joinable!(channel_permissions -> channels (channel_uuid));
 diesel::joinable!(channels -> guilds (guild_uuid));
 diesel::joinable!(guild_members -> guilds (guild_uuid));
 diesel::joinable!(guild_members -> users (user_uuid));
+diesel::joinable!(guilds -> users (owner_uuid));
 diesel::joinable!(instance_permissions -> users (uuid));
 diesel::joinable!(invites -> guilds (guild_uuid));
 diesel::joinable!(invites -> users (user_uuid));

src/structs.rs

@@ -0,0 +1,781 @@
+use std::path::Path;
+
+use actix_web::web::BytesMut;
+use diesel::{
+    ExpressionMethods, QueryDsl, Selectable, SelectableHelper, delete, insert_into,
+    prelude::{Insertable, Queryable},
+    update,
+};
+use diesel_async::{RunQueryDsl, pooled_connection::AsyncDieselConnectionManager};
+use serde::{Deserialize, Serialize};
+use tokio::{fs::{create_dir_all, remove_file, File}, io::AsyncWriteExt, task};
+use url::Url;
+use uuid::Uuid;
+
+use crate::{config::Config, error::Error, schema::*, utils::image_check, Conn, Data};
+
+fn load_or_empty<T>(
+    query_result: Result<Vec<T>, diesel::result::Error>,
+) -> Result<Vec<T>, diesel::result::Error> {
+    match query_result {
+        Ok(vec) => Ok(vec),
+        Err(diesel::result::Error::NotFound) => Ok(Vec::new()),
+        Err(e) => Err(e),
+    }
+}
+
+#[derive(Clone)]
+pub struct Storage {
+    bunny_cdn: Option<bunny_api_tokio::Client>,
+    cdn_url: Url,
+    data_dir: String,
+}
+
+impl Storage {
+    pub async fn new(config: Config, data_dir: String) -> Result<Self, Error> {
+        let mut bunny_cdn;
+        let cdn_url;
+
+        if let Some(bunny) = config.bunny {
+            bunny_cdn = Some(bunny_api_tokio::Client::new("").await?);
+        
+            bunny_cdn
+                .as_mut()
+                .unwrap()
+                .storage
+                .init(bunny.api_key, bunny.endpoint, bunny.storage_zone)
+                .await?;
+
+            cdn_url = bunny.cdn_url;
+        } else {
+            bunny_cdn = None;
+            cdn_url = config.web.url.join("api/assets/")?;
+        }
+
+        Ok(Self {
+            bunny_cdn,
+            data_dir,
+            cdn_url
+        })
+    }
+
+    pub async fn write<T: AsRef<str>>(&self, path: T, bytes: BytesMut) -> Result<Url, Error> {
+        if let Some(bunny_cdn) = &self.bunny_cdn {
+            bunny_cdn.storage.upload(&path, bytes.into()).await?;
+            Ok(self.cdn_url.join(&path.as_ref())?)
+        } else {
+            let file_path = Path::new(&self.data_dir);
+
+            let file_path = file_path.join(path.as_ref());
+
+            create_dir_all(file_path.parent().ok_or(Error::PathError("Unable to get parent directory".to_string()))?).await?;
+
+            let mut file = File::create(file_path).await?;
+
+            file.write_all(&bytes).await?;
+
+            Ok(self.cdn_url.join(path.as_ref())?)
+        }
+    }
+
+    pub async fn delete<T: AsRef<str>>(&self, path: T) -> Result<(), Error> {
+        if let Some(bunny_cdn) = &self.bunny_cdn {
+            Ok(bunny_cdn.storage.delete(&path).await?)
+        } else {
+            let file_path = Path::new(&self.data_dir);
+
+            let file_path = file_path.join(path.as_ref());
+
+            remove_file(file_path).await?;
+            Ok(())
+        }
+    }
+}
+
+#[derive(Queryable, Selectable, Insertable, Clone)]
+#[diesel(table_name = channels)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
+struct ChannelBuilder {
+    uuid: Uuid,
+    guild_uuid: Uuid,
+    name: String,
+    description: Option<String>,
+}
+
+impl ChannelBuilder {
+    async fn build(self, conn: &mut Conn) -> Result<Channel, Error> {
+        use self::channel_permissions::dsl::*;
+        let channel_permission: Vec<ChannelPermission> = load_or_empty(
+            channel_permissions
+                .filter(channel_uuid.eq(self.uuid))
+                .select(ChannelPermission::as_select())
+                .load(conn)
+                .await,
+        )?;
+
+        Ok(Channel {
+            uuid: self.uuid,
+            guild_uuid: self.guild_uuid,
+            name: self.name,
+            description: self.description,
+            permissions: channel_permission,
+        })
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone)]
+pub struct Channel {
+    pub uuid: Uuid,
+    pub guild_uuid: Uuid,
+    name: String,
+    description: Option<String>,
+    pub permissions: Vec<ChannelPermission>,
+}
+
+#[derive(Serialize, Deserialize, Clone, Queryable, Selectable)]
+#[diesel(table_name = channel_permissions)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
+pub struct ChannelPermission {
+    pub role_uuid: Uuid,
+    pub permissions: i64,
+}
+
+impl Channel {
+    pub async fn fetch_all(
+        pool: &deadpool::managed::Pool<
+            AsyncDieselConnectionManager<diesel_async::AsyncPgConnection>,
+            Conn,
+        >,
+        guild_uuid: Uuid,
+    ) -> Result<Vec<Self>, Error> {
+        let mut conn = pool.get().await?;
+
+        use channels::dsl;
+        let channel_builders: Vec<ChannelBuilder> = load_or_empty(
+            dsl::channels
+                .filter(dsl::guild_uuid.eq(guild_uuid))
+                .select(ChannelBuilder::as_select())
+                .load(&mut conn)
+                .await,
+        )?;
+
+        let channel_futures = channel_builders.iter().map(async move |c| {
+            let mut conn = pool.get().await?;
+            c.clone().build(&mut conn).await
+        });
+
+        futures::future::try_join_all(channel_futures).await
+    }
+
+    pub async fn fetch_one(conn: &mut Conn, channel_uuid: Uuid) -> Result<Self, Error> {
+        use channels::dsl;
+        let channel_builder: ChannelBuilder = dsl::channels
+            .filter(dsl::uuid.eq(channel_uuid))
+            .select(ChannelBuilder::as_select())
+            .get_result(conn)
+            .await?;
+
+        channel_builder.build(conn).await
+    }
+
+    pub async fn new(
+        data: actix_web::web::Data<Data>,
+        guild_uuid: Uuid,
+        name: String,
+        description: Option<String>,
+    ) -> Result<Self, Error> {
+        let mut conn = data.pool.get().await?;
+
+        let channel_uuid = Uuid::now_v7();
+
+        let new_channel = ChannelBuilder {
+            uuid: channel_uuid,
+            guild_uuid,
+            name: name.clone(),
+            description: description.clone(),
+        };
+
+        insert_into(channels::table)
+            .values(new_channel)
+            .execute(&mut conn)
+            .await?;
+
+        // returns different object because there's no reason to build the channelbuilder (wastes 1 database request)
+        let channel = Self {
+            uuid: channel_uuid,
+            guild_uuid,
+            name,
+            description,
+            permissions: vec![],
+        };
+
+        data.set_cache_key(channel_uuid.to_string(), channel.clone(), 1800)
+            .await?;
+
+        data.del_cache_key(format!("{}_channels", guild_uuid))
+            .await?;
+
+        Ok(channel)
+    }
+
+    pub async fn delete(self, conn: &mut Conn) -> Result<(), Error> {
+        use channels::dsl;
+        delete(channels::table)
+            .filter(dsl::uuid.eq(self.uuid))
+            .execute(conn)
+            .await?;
+
+        Ok(())
+    }
+
+    pub async fn fetch_messages(
+        &self,
+        conn: &mut Conn,
+        amount: i64,
+        offset: i64,
+    ) -> Result<Vec<Message>, Error> {
+        use messages::dsl;
+        let messages: Vec<Message> = load_or_empty(
+            dsl::messages
+                .filter(dsl::channel_uuid.eq(self.uuid))
+                .select(Message::as_select())
+                .limit(amount)
+                .offset(offset)
+                .load(conn)
+                .await,
+        )?;
+
+        Ok(messages)
+    }
+
+    pub async fn new_message(
+        &self,
+        conn: &mut Conn,
+        user_uuid: Uuid,
+        message: String,
+    ) -> Result<Message, Error> {
+        let message_uuid = Uuid::now_v7();
+
+        let message = Message {
+            uuid: message_uuid,
+            channel_uuid: self.uuid,
+            user_uuid,
+            message,
+        };
+
+        insert_into(messages::table)
+            .values(message.clone())
+            .execute(conn)
+            .await?;
+
+        Ok(message)
+    }
+}
+
+#[derive(Clone, Copy)]
+pub enum Permissions {
+    SendMessage = 1,
+    CreateChannel = 2,
+    DeleteChannel = 4,
+    ManageChannel = 8,
+    CreateRole = 16,
+    DeleteRole = 32,
+    ManageRole = 64,
+    CreateInvite = 128,
+    ManageInvite = 256,
+    ManageServer = 512,
+    ManageMember = 1024,
+}
+
+impl Permissions {
+    pub fn fetch_permissions(permissions: i64) -> Vec<Self> {
+        let all_perms = vec![
+            Self::SendMessage,
+            Self::CreateChannel,
+            Self::DeleteChannel,
+            Self::ManageChannel,
+            Self::CreateRole,
+            Self::DeleteRole,
+            Self::ManageRole,
+            Self::CreateInvite,
+            Self::ManageInvite,
+            Self::ManageServer,
+            Self::ManageMember,
+        ];
+
+        all_perms
+            .into_iter()
+            .filter(|p| permissions & (*p as i64) != 0)
+            .collect()
+    }
+}
+
+#[derive(Serialize, Queryable, Selectable, Insertable, Clone)]
+#[diesel(table_name = guilds)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
+struct GuildBuilder {
+    uuid: Uuid,
+    name: String,
+    description: Option<String>,
+    icon: Option<String>,
+    owner_uuid: Uuid,
+}
+
+impl GuildBuilder {
+    async fn build(self, conn: &mut Conn) -> Result<Guild, Error> {
+        let member_count = Member::count(conn, self.uuid).await?;
+
+        let roles = Role::fetch_all(conn, self.uuid).await?;
+
+        Ok(Guild {
+            uuid: self.uuid,
+            name: self.name,
+            description: self.description,
+            icon: self.icon.and_then(|i| i.parse().ok()),
+            owner_uuid: self.owner_uuid,
+            roles,
+            member_count,
+        })
+    }
+}
+
+#[derive(Serialize)]
+pub struct Guild {
+    pub uuid: Uuid,
+    name: String,
+    description: Option<String>,
+    icon: Option<Url>,
+    owner_uuid: Uuid,
+    pub roles: Vec<Role>,
+    member_count: i64,
+}
+
+impl Guild {
+    pub async fn fetch_one(conn: &mut Conn, guild_uuid: Uuid) -> Result<Self, Error> {
+        use guilds::dsl;
+        let guild_builder: GuildBuilder = dsl::guilds
+            .filter(dsl::uuid.eq(guild_uuid))
+            .select(GuildBuilder::as_select())
+            .get_result(conn)
+            .await?;
+
+        guild_builder.build(conn).await
+    }
+
+    pub async fn fetch_amount(
+        pool: &deadpool::managed::Pool<
+            AsyncDieselConnectionManager<diesel_async::AsyncPgConnection>,
+            Conn,
+        >,
+        offset: i64,
+        amount: i64,
+    ) -> Result<Vec<Self>, Error> {
+        // Fetch guild data from database
+        let mut conn = pool.get().await?;
+
+        use guilds::dsl;
+        let guild_builders: Vec<GuildBuilder> = load_or_empty(
+            dsl::guilds
+                .select(GuildBuilder::as_select())
+                .order_by(dsl::uuid)
+                .offset(offset)
+                .limit(amount)
+                .load(&mut conn)
+                .await,
+        )?;
+
+        // Process each guild concurrently
+        let guild_futures = guild_builders.iter().map(async move |g| {
+            let mut conn = pool.get().await?;
+            g.clone().build(&mut conn).await
+        });
+
+        // Execute all futures concurrently and collect results
+        futures::future::try_join_all(guild_futures).await
+    }
+
+    pub async fn new(
+        conn: &mut Conn,
+        name: String,
+        description: Option<String>,
+        owner_uuid: Uuid,
+    ) -> Result<Self, Error> {
+        let guild_uuid = Uuid::now_v7();
+
+        let guild_builder = GuildBuilder {
+            uuid: guild_uuid,
+            name: name.clone(),
+            description: description.clone(),
+            icon: None,
+            owner_uuid,
+        };
+
+        insert_into(guilds::table)
+            .values(guild_builder)
+            .execute(conn)
+            .await?;
+
+        let member_uuid = Uuid::now_v7();
+
+        let member = Member {
+            uuid: member_uuid,
+            nickname: None,
+            user_uuid: owner_uuid,
+            guild_uuid,
+        };
+
+        insert_into(guild_members::table)
+            .values(member)
+            .execute(conn)
+            .await?;
+
+        Ok(Guild {
+            uuid: guild_uuid,
+            name,
+            description,
+            icon: None,
+            owner_uuid,
+            roles: vec![],
+            member_count: 1,
+        })
+    }
+
+    pub async fn get_invites(&self, conn: &mut Conn) -> Result<Vec<Invite>, Error> {
+        use invites::dsl;
+        let invites = load_or_empty(
+            dsl::invites
+                .filter(dsl::guild_uuid.eq(self.uuid))
+                .select(Invite::as_select())
+                .load(conn)
+                .await,
+        )?;
+
+        Ok(invites)
+    }
+
+    pub async fn create_invite(
+        &self,
+        conn: &mut Conn,
+        member: &Member,
+        custom_id: Option<String>,
+    ) -> Result<Invite, Error> {
+        let invite_id;
+
+        if let Some(id) = custom_id {
+            invite_id = id;
+            if invite_id.len() > 32 {
+                return Err(Error::BadRequest("MAX LENGTH".to_string()));
+            }
+        } else {
+            let charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+
+            invite_id = random_string::generate(8, charset);
+        }
+
+        let invite = Invite {
+            id: invite_id,
+            user_uuid: member.user_uuid,
+            guild_uuid: self.uuid,
+        };
+
+        insert_into(invites::table)
+            .values(invite.clone())
+            .execute(conn)
+            .await?;
+
+        Ok(invite)
+    }
+
+    // FIXME: Horrible security
+    pub async fn set_icon(
+        &mut self,
+        storage: &Storage,
+        conn: &mut Conn,
+        icon: BytesMut,
+    ) -> Result<(), Error> {
+        let icon_clone = icon.clone();
+        let image_type = task::spawn_blocking(move || image_check(icon_clone)).await??;
+
+        if let Some(icon) = &self.icon {
+            let relative_url = icon.path().trim_start_matches('/');
+
+            storage.delete(relative_url).await?;
+        }
+
+        let path = format!("icons/{}/icon.{}", self.uuid, image_type);
+
+        let icon_url = storage.write(path.clone(), icon.into()).await?;
+
+        use guilds::dsl;
+        update(guilds::table)
+            .filter(dsl::uuid.eq(self.uuid))
+            .set(dsl::icon.eq(icon_url.as_str()))
+            .execute(conn)
+            .await?;
+
+        self.icon = Some(icon_url);
+
+        Ok(())
+    }
+}
+
+#[derive(Serialize, Clone, Queryable, Selectable, Insertable)]
+#[diesel(table_name = roles)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
+pub struct Role {
+    uuid: Uuid,
+    guild_uuid: Uuid,
+    name: String,
+    color: i32,
+    position: i32,
+    permissions: i64,
+}
+
+impl Role {
+    pub async fn fetch_all(conn: &mut Conn, guild_uuid: Uuid) -> Result<Vec<Self>, Error> {
+        use roles::dsl;
+        let roles: Vec<Role> = load_or_empty(
+            dsl::roles
+                .filter(dsl::guild_uuid.eq(guild_uuid))
+                .select(Role::as_select())
+                .load(conn)
+                .await,
+        )?;
+
+        Ok(roles)
+    }
+
+    pub async fn fetch_one(conn: &mut Conn, role_uuid: Uuid) -> Result<Self, Error> {
+        use roles::dsl;
+        let role: Role = dsl::roles
+            .filter(dsl::uuid.eq(role_uuid))
+            .select(Role::as_select())
+            .get_result(conn)
+            .await?;
+
+        Ok(role)
+    }
+
+    pub async fn new(conn: &mut Conn, guild_uuid: Uuid, name: String) -> Result<Self, Error> {
+        let role_uuid = Uuid::now_v7();
+
+        let role = Role {
+            uuid: role_uuid,
+            guild_uuid,
+            name,
+            color: 16777215,
+            position: 0,
+            permissions: 0,
+        };
+
+        insert_into(roles::table)
+            .values(role.clone())
+            .execute(conn)
+            .await?;
+
+        Ok(role)
+    }
+}
+
+#[derive(Queryable, Selectable, Insertable)]
+#[diesel(table_name = guild_members)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
+pub struct Member {
+    pub uuid: Uuid,
+    pub nickname: Option<String>,
+    pub user_uuid: Uuid,
+    pub guild_uuid: Uuid,
+}
+
+impl Member {
+    async fn count(conn: &mut Conn, guild_uuid: Uuid) -> Result<i64, Error> {
+        use guild_members::dsl;
+        let count: i64 = dsl::guild_members
+            .filter(dsl::guild_uuid.eq(guild_uuid))
+            .count()
+            .get_result(conn)
+            .await?;
+
+        Ok(count)
+    }
+
+    pub async fn fetch_one(
+        conn: &mut Conn,
+        user_uuid: Uuid,
+        guild_uuid: Uuid,
+    ) -> Result<Self, Error> {
+        use guild_members::dsl;
+        let member: Member = dsl::guild_members
+            .filter(dsl::user_uuid.eq(user_uuid))
+            .filter(dsl::guild_uuid.eq(guild_uuid))
+            .select(Member::as_select())
+            .get_result(conn)
+            .await?;
+
+        Ok(member)
+    }
+
+    pub async fn new(conn: &mut Conn, user_uuid: Uuid, guild_uuid: Uuid) -> Result<Self, Error> {
+        let member_uuid = Uuid::now_v7();
+
+        let member = Member {
+            uuid: member_uuid,
+            guild_uuid,
+            user_uuid,
+            nickname: None,
+        };
+
+        insert_into(guild_members::table)
+            .values(member)
+            .execute(conn)
+            .await?;
+
+        Ok(Self {
+            uuid: member_uuid,
+            nickname: None,
+            user_uuid,
+            guild_uuid,
+        })
+    }
+}
+
+#[derive(Clone, Serialize, Queryable, Selectable, Insertable)]
+#[diesel(table_name = messages)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
+pub struct Message {
+    uuid: Uuid,
+    channel_uuid: Uuid,
+    user_uuid: Uuid,
+    message: String,
+}
+
+/// Server invite struct
+#[derive(Clone, Serialize, Queryable, Selectable, Insertable)]
+pub struct Invite {
+    /// case-sensitive alphanumeric string with a fixed length of 8 characters, can be up to 32 characters for custom invites
+    id: String,
+    /// User that created the invite
+    user_uuid: Uuid,
+    /// UUID of the guild that the invite belongs to
+    pub guild_uuid: Uuid,
+}
+
+impl Invite {
+    pub async fn fetch_one(conn: &mut Conn, invite_id: String) -> Result<Self, Error> {
+        use invites::dsl;
+        let invite: Invite = dsl::invites
+            .filter(dsl::id.eq(invite_id))
+            .select(Invite::as_select())
+            .get_result(conn)
+            .await?;
+
+        Ok(invite)
+    }
+}
+
+#[derive(Serialize, Clone, Queryable, Selectable)]
+#[diesel(table_name = users)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
+pub struct User {
+    uuid: Uuid,
+    username: String,
+    display_name: Option<String>,
+    avatar: Option<String>,
+}
+
+impl User {
+    pub async fn fetch_one(conn: &mut Conn, user_uuid: Uuid) -> Result<Self, Error> {
+        use users::dsl;
+        let user: User = dsl::users
+            .filter(dsl::uuid.eq(user_uuid))
+            .select(User::as_select())
+            .get_result(conn)
+            .await?;
+
+        Ok(user)
+    }
+
+    pub async fn fetch_amount(
+        conn: &mut Conn,
+        offset: i64,
+        amount: i64,
+    ) -> Result<Vec<Self>, Error> {
+        use users::dsl;
+        let users: Vec<User> = load_or_empty(
+            dsl::users
+                .limit(amount)
+                .offset(offset)
+                .select(User::as_select())
+                .load(conn)
+                .await,
+        )?;
+
+        Ok(users)
+    }
+}
+
+#[derive(Serialize, Queryable, Selectable)]
+#[diesel(table_name = users)]
+#[diesel(check_for_backend(diesel::pg::Pg))]
+pub struct Me {
+    uuid: Uuid,
+    username: String,
+    display_name: Option<String>,
+    avatar: Option<String>,
+    email: String,
+    email_verified: bool,
+}
+
+impl Me {
+    pub async fn get(conn: &mut Conn, user_uuid: Uuid) -> Result<Self, Error> {
+        use users::dsl;
+        let me: Me = dsl::users
+            .filter(dsl::uuid.eq(user_uuid))
+            .select(Me::as_select())
+            .get_result(conn)
+            .await?;
+
+        Ok(me)
+    }
+
+    pub async fn set_avatar(
+        &mut self,
+        storage: &Storage,
+        conn: &mut Conn,
+        avatar: BytesMut,
+    ) -> Result<(), Error> {
+        let avatar_clone = avatar.clone();
+        let image_type = task::spawn_blocking(move || image_check(avatar_clone)).await??;
+
+        if let Some(avatar) = &self.avatar {
+            let avatar_url: Url = avatar.parse()?;
+
+            let relative_url = avatar_url.path().trim_start_matches('/');
+
+            storage.delete(relative_url).await?;
+        }
+
+        let path = format!("avatar/{}/avatar.{}", self.uuid, image_type);
+
+        let avatar_url = storage
+            .write(path.clone(), avatar.into())
+            .await?;
+
+        use users::dsl;
+        update(users::table)
+            .filter(dsl::uuid.eq(self.uuid))
+            .set(dsl::avatar.eq(avatar_url.as_str()))
+            .execute(conn)
+            .await?;
+
+        self.avatar = Some(avatar_url.to_string());
+
+        Ok(())
+    }
+}
+
+#[derive(Deserialize)]
+pub struct StartAmountQuery {
+    pub start: Option<i64>,
+    pub amount: Option<i64>,
+}

src/utils.rs

@@ -1,40 +1,15 @@
-use std::sync::LazyLock;
-
 use actix_web::{
     cookie::{Cookie, SameSite, time::Duration},
     http::header::HeaderMap,
     web::BytesMut,
 };
 use bindet::FileType;
-use diesel::{ExpressionMethods, QueryDsl};
-use diesel_async::RunQueryDsl;
 use getrandom::fill;
 use hex::encode;
 use redis::RedisError;
-use regex::Regex;
 use serde::Serialize;
-use uuid::Uuid;
 
-use crate::{
+use crate::{Data, error::Error};
-    Conn, Data,
-    config::Config,
-    error::Error,
-    objects::{HasIsAbove, HasUuid},
-    schema::users,
-};
-
-pub static EMAIL_REGEX: LazyLock<Regex> = LazyLock::new(|| {
-    Regex::new(r"[-A-Za-z0-9!#$%&'*+/=?^_`{|}~]+(?:\.[-A-Za-z0-9!#$%&'*+/=?^_`{|}~]+)*@(?:[A-Za-z0-9](?:[-A-Za-z0-9]*[A-Za-z0-9])?\.)+[A-Za-z0-9](?:[-A-Za-z0-9]*[A-Za-z0-9])?").unwrap()
-});
-
-pub static USERNAME_REGEX: LazyLock<Regex> =
-    LazyLock::new(|| Regex::new(r"^[a-z0-9_.-]+$").unwrap());
-
-pub static CHANNEL_REGEX: LazyLock<Regex> =
-    LazyLock::new(|| Regex::new(r"^[a-z0-9_.-]+$").unwrap());
-
-// Password is expected to be hashed using SHA3-384
-pub static PASSWORD_REGEX: LazyLock<Regex> = LazyLock::new(|| Regex::new(r"[0-9a-f]{96}").unwrap());
 
 pub fn get_auth_header(headers: &HeaderMap) -> Result<&str, Error> {
     let auth_token = headers.get(actix_web::http::header::AUTHORIZATION);
@@ -70,53 +45,24 @@ pub fn get_auth_header(headers: &HeaderMap) -> Result<&str, Error> {
     Ok(auth_value.unwrap())
 }
 
-pub fn get_ws_protocol_header(headers: &HeaderMap) -> Result<&str, Error> {
+pub fn refresh_token_cookie(refresh_token: String) -> Cookie<'static> {
-    let auth_token = headers.get(actix_web::http::header::SEC_WEBSOCKET_PROTOCOL);
-
-    if auth_token.is_none() {
-        return Err(Error::Unauthorized(
-            "No authorization header provided".to_string(),
-        ));
-    }
-
-    let auth_raw = auth_token.unwrap().to_str()?;
-
-    let mut auth = auth_raw.split_whitespace();
-
-    let response_proto = auth.next();
-
-    let auth_value = auth.next();
-
-    if response_proto.is_none() {
-        return Err(Error::BadRequest(
-            "Sec-WebSocket-Protocol header is empty".to_string(),
-        ));
-    } else if response_proto.is_some_and(|rp| rp != "Authorization,") {
-        return Err(Error::BadRequest(
-            "First protocol should be Authorization".to_string(),
-        ));
-    }
-
-    if auth_value.is_none() {
-        return Err(Error::BadRequest("No token provided".to_string()));
-    }
-
-    Ok(auth_value.unwrap())
-}
-
-pub fn new_refresh_token_cookie(config: &Config, refresh_token: String) -> Cookie<'static> {
     Cookie::build("refresh_token", refresh_token)
         .http_only(true)
         .secure(true)
         .same_site(SameSite::None)
-        //.domain(config.web.backend_url.domain().unwrap().to_string())
+        .path("/api")
-        .path(config.web.backend_url.path().to_string())
         .max_age(Duration::days(30))
         .finish()
 }
 
-pub fn generate_token<const N: usize>() -> Result<String, getrandom::Error> {
+pub fn generate_access_token() -> Result<String, getrandom::Error> {
-    let mut buf = [0u8; N];
+    let mut buf = [0u8; 16];
+    fill(&mut buf)?;
+    Ok(encode(buf))
+}
+
+pub fn generate_refresh_token() -> Result<String, getrandom::Error> {
+    let mut buf = [0u8; 32];
     fill(&mut buf)?;
     Ok(encode(buf))
 }
@@ -139,81 +85,6 @@ pub fn image_check(icon: BytesMut) -> Result<String, Error> {
     ))
 }
 
-pub async fn user_uuid_from_identifier(
-    conn: &mut Conn,
-    identifier: &String,
-) -> Result<Uuid, Error> {
-    if EMAIL_REGEX.is_match(identifier) {
-        use users::dsl;
-        let user_uuid = dsl::users
-            .filter(dsl::email.eq(identifier))
-            .select(dsl::uuid)
-            .get_result(conn)
-            .await?;
-
-        Ok(user_uuid)
-    } else if USERNAME_REGEX.is_match(identifier) {
-        use users::dsl;
-        let user_uuid = dsl::users
-            .filter(dsl::username.eq(identifier))
-            .select(dsl::uuid)
-            .get_result(conn)
-            .await?;
-
-        Ok(user_uuid)
-    } else {
-        Err(Error::BadRequest(
-            "Please provide a valid username or email".to_string(),
-        ))
-    }
-}
-
-pub async fn global_checks(data: &Data, user_uuid: Uuid) -> Result<(), Error> {
-    if data.config.instance.require_email_verification {
-        let mut conn = data.pool.get().await?;
-
-        use users::dsl;
-        let email_verified: bool = dsl::users
-            .filter(dsl::uuid.eq(user_uuid))
-            .select(dsl::email_verified)
-            .get_result(&mut conn)
-            .await?;
-
-        if !email_verified {
-            return Err(Error::Forbidden(
-                "server requires email verification".to_string(),
-            ));
-        }
-    }
-
-    Ok(())
-}
-
-pub async fn order_by_is_above<T>(mut items: Vec<T>) -> Result<Vec<T>, Error>
-where
-    T: HasUuid + HasIsAbove,
-{
-    let mut ordered = Vec::new();
-
-    // Find head
-    let head_pos = items
-        .iter()
-        .position(|item| !items.iter().any(|i| i.is_above() == Some(item.uuid())));
-
-    if let Some(pos) = head_pos {
-        ordered.push(items.swap_remove(pos));
-
-        while let Some(next_pos) = items
-            .iter()
-            .position(|item| Some(item.uuid()) == ordered.last().unwrap().is_above())
-        {
-            ordered.push(items.swap_remove(next_pos));
-        }
-    }
-
-    Ok(ordered)
-}
-
 impl Data {
     pub async fn set_cache_key(
         &self,