move all direct database access to logic crate

11 files changed, 114 insertions, 327 deletions

diff --git a/server/src/ui/account/mod.rs b/server/src/ui/account/mod.rs
index 51da348..2a513a9 100644
--- a/server/src/ui/account/mod.rs
+++ b/server/src/ui/account/mod.rs
@@ -11,13 +11,8 @@ use crate::{
     ui::{error::MyResult, home::rocket_uri_macro_r_home},
 };
 use anyhow::anyhow;
-use jellycommon::user::User;
 use jellyimport::is_importing;
-use jellylogic::{
-    login::{hash_password, login_logic},
-    session::Session,
-    Database,
-};
+use jellylogic::{account::register_user, login::login_logic, session::Session};
 use jellyui::{
     account::{AccountLogin, AccountLogout, AccountRegister, AccountRegisterSuccess},
     render_page,
@@ -29,7 +24,7 @@ use rocket::{
     http::{Cookie, CookieJar},
     post,
     response::{content::RawHtml, Redirect},
-    FromForm, State,
+    FromForm,
 };
 use serde::{Deserialize, Serialize};
 
@@ -98,7 +93,6 @@ pub fn r_account_logout(session: Option<A<Session>>, lang: AcceptLanguage) -> Ra
 
 #[post("/account/register", data = "<form>")]
 pub fn r_account_register_post<'a>(
-    database: &'a State<Database>,
     session: Option<A<Session>>,
     form: Form<Contextual<'a, RegisterForm>>,
     lang: AcceptLanguage,
@@ -110,16 +104,7 @@ pub fn r_account_register_post<'a>(
         None => return Err(MyError(anyhow!(format_form_error(form)))),
     };
 
-    database.register_user(
-        &form.invitation,
-        &form.username,
-        User {
-            display_name: form.username.clone(),
-            name: form.username.clone(),
-            password: hash_password(&form.username, &form.password),
-            ..Default::default()
-        },
-    )?;
+    register_user(&form.invitation, &form.username, &form.password)?;
 
     Ok(RawHtml(render_page(
         &AccountRegisterSuccess {
@@ -136,7 +121,6 @@ pub fn r_account_register_post<'a>(
 
 #[post("/account/login", data = "<form>")]
 pub fn r_account_login_post(
-    database: &State<Database>,
     jar: &CookieJar,
     form: Form<Contextual<LoginForm>>,
 ) -> MyResult<Redirect> {
@@ -147,7 +131,7 @@ pub fn r_account_login_post(
     jar.add(
         Cookie::build((
             "session",
-            login_logic(database, &form.username, &form.password, None, None)?,
+            login_logic(&form.username, &form.password, None, None)?,
         ))
         .permanent()
         .build(),
diff --git a/server/src/ui/account/settings.rs b/server/src/ui/account/settings.rs
index f1a367d..7d1b7af 100644
--- a/server/src/ui/account/settings.rs
+++ b/server/src/ui/account/settings.rs
@@ -3,14 +3,20 @@
     which is licensed under the GNU Affero General Public License (version 3); see /COPYING.
     Copyright (C) 2025 metamuffin <metamuffin.org>
 */
-use super::{format_form_error, hash_password};
+use super::format_form_error;
 use crate::{
     helper::{language::AcceptLanguage, A},
     ui::error::MyResult,
 };
 use jellycommon::user::{PlayerKind, Theme};
 use jellyimport::is_importing;
-use jellylogic::{session::Session, Database};
+use jellylogic::{
+    account::{
+        update_user_display_name, update_user_native_secret, update_user_password,
+        update_user_player_preference, update_user_theme,
+    },
+    session::Session,
+};
 use jellyui::{
     account::settings::SettingsPage,
     locale::{tr, Language},
@@ -21,7 +27,7 @@ use rocket::{
     form::{self, validate::len, Contextual, Form},
     get, post,
     response::content::RawHtml,
-    FromForm, State,
+    FromForm,
 };
 use std::ops::Range;
 
@@ -70,7 +76,6 @@ pub fn r_account_settings(session: A<Session>, lang: AcceptLanguage) -> RawHtml<
 #[post("/account/settings", data = "<form>")]
 pub fn r_account_settings_post(
     session: A<Session>,
-    database: &State<Database>,
     form: Form<Contextual<SettingsForm>>,
     lang: AcceptLanguage,
 ) -> MyResult<RawHtml<String>> {
@@ -90,33 +95,30 @@ pub fn r_account_settings_post(
 
     let mut out = String::new();
 
-    database.update_user(&session.user.name, |user| {
-        if let Some(password) = &form.password {
-            user.password = hash_password(&session.user.name, password);
-            out += &*tr(lang, "settings.account.password.changed");
-            out += "\n";
-        }
-        if let Some(display_name) = &form.display_name {
-            user.display_name = display_name.clone();
-            out += &*tr(lang, "settings.account.display_name.changed");
-            out += "\n";
-        }
-        if let Some(theme) = form.theme {
-            user.theme = theme.0;
-            out += &*tr(lang, "settings.account.theme.changed");
-            out += "\n";
-        }
-        if let Some(player_preference) = form.player_preference {
-            user.player_preference = player_preference.0;
-            out += &*tr(lang, "settings.player_preference.changed");
-            out += "\n";
-        }
-        if let Some(native_secret) = &form.native_secret {
-            user.native_secret = native_secret.to_owned();
-            out += "Native secret updated.\n";
-        }
-        Ok(())
-    })?;
+    if let Some(password) = &form.password {
+        update_user_password(&session, password)?;
+        out += &*tr(lang, "settings.account.password.changed");
+        out += "\n";
+    }
+    if let Some(display_name) = &form.display_name {
+        update_user_display_name(&session, display_name)?;
+        out += &*tr(lang, "settings.account.display_name.changed");
+        out += "\n";
+    }
+    if let Some(theme) = form.theme {
+        update_user_theme(&session, theme.0)?;
+        out += &*tr(lang, "settings.account.theme.changed");
+        out += "\n";
+    }
+    if let Some(player_preference) = form.player_preference {
+        update_user_player_preference(&session, player_preference.0)?;
+        out += &*tr(lang, "settings.player_preference.changed");
+        out += "\n";
+    }
+    if let Some(native_secret) = &form.native_secret {
+        update_user_native_secret(&session, native_secret)?;
+        out += "Native secret updated.\n";
+    }
 
     Ok(settings_page(
         session, // using the old session here, results in outdated theme being displayed
diff --git a/server/src/ui/admin/mod.rs b/server/src/ui/admin/mod.rs
index 942f4f8..e3eb2d6 100644
--- a/server/src/ui/admin/mod.rs
+++ b/server/src/ui/admin/mod.rs
@@ -6,50 +6,42 @@
 pub mod log;
 pub mod user;
 
-use super::{
-    assets::{resolve_asset, AVIF_QUALITY, AVIF_SPEED},
-    error::MyResult,
-};
+use super::error::MyResult;
 use crate::helper::{language::AcceptLanguage, A};
-use anyhow::{anyhow, Context};
 use jellycommon::routes::u_admin_dashboard;
-use jellyimport::{asset_token::AssetInner, import_wrap, is_importing};
+use jellyimport::is_importing;
 use jellylogic::{
-    admin::{get_import_errors, list_invites},
+    admin::{
+        create_invite, delete_invite, do_import, get_import_errors, list_invites,
+        update_search_index,
+    },
     session::AdminSession,
-    Database,
 };
 use jellyui::{
     admin::AdminDashboardPage,
     render_page,
     scaffold::{RenderInfo, SessionInfo},
 };
-use rand::Rng;
 use rocket::{
     form::Form,
     get, post,
     response::{content::RawHtml, Redirect},
-    FromForm, State,
+    FromForm,
 };
-use std::time::Instant;
-use tokio::{sync::Semaphore, task::spawn_blocking};
 
 #[get("/admin/dashboard")]
 pub async fn r_admin_dashboard(
     session: A<AdminSession>,
-    database: &State<Database>,
     lang: AcceptLanguage,
 ) -> MyResult<RawHtml<String>> {
     let AcceptLanguage(lang) = lang;
     let flash = None;
 
-    let invites = list_invites(&session.0, database)?;
+    let invites = list_invites(&session.0)?;
     let last_import_err = get_import_errors(&session.0).await;
 
     let busy = if is_importing() {
         Some("An import is currently running.")
-    } else if is_transcoding() {
-        Some("Currently transcoding posters.")
     } else {
         None
     };
@@ -73,13 +65,8 @@ pub async fn r_admin_dashboard(
 }
 
 #[post("/admin/generate_invite")]
-pub async fn r_admin_invite(
-    _session: A<AdminSession>,
-    database: &State<Database>,
-) -> MyResult<Redirect> {
-    let i = format!("{}", rand::rng().random::<u128>());
-    database.create_invite(&i)?;
-    // admin_dashboard(database, Some(Ok(format!("Invite: {}", i)))).await
+pub async fn r_admin_invite(session: A<AdminSession>) -> MyResult<Redirect> {
+    let _ = create_invite(&session.0)?;
     Ok(Redirect::temporary(u_admin_dashboard()))
 }
 
@@ -91,97 +78,20 @@ pub struct DeleteInvite {
 #[post("/admin/remove_invite", data = "<form>")]
 pub async fn r_admin_remove_invite(
     session: A<AdminSession>,
-    database: &State<Database>,
     form: Form<DeleteInvite>,
 ) -> MyResult<Redirect> {
-    drop(session);
-    if !database.delete_invite(&form.invite)? {
-        Err(anyhow!("invite does not exist"))?;
-    };
-    // admin_dashboard(database, Some(Ok("Invite invalidated".into()))).await
+    delete_invite(&session.0, &form.invite)?;
     Ok(Redirect::temporary(u_admin_dashboard()))
 }
 
 #[post("/admin/import?<incremental>")]
-pub async fn r_admin_import(
-    session: A<AdminSession>,
-    database: &State<Database>,
-    incremental: bool,
-) -> MyResult<Redirect> {
-    drop(session);
-    let t = Instant::now();
-    if !incremental {
-        database.clear_nodes()?;
-    }
-    let r = import_wrap((*database).clone(), incremental).await;
-    // let flash = r
-    //     .map_err(|e| e.into())
-    //     .map(|_| format!("Import successful; took {:?}", t.elapsed()));
-    // admin_dashboard(database, Some(flash)).await
+pub async fn r_admin_import(session: A<AdminSession>, incremental: bool) -> MyResult<Redirect> {
+    do_import(&session.0, incremental).await?.1?;
     Ok(Redirect::temporary(u_admin_dashboard()))
 }
 
 #[post("/admin/update_search")]
-pub async fn r_admin_update_search(
-    _session: A<AdminSession>,
-    database: &State<Database>,
-) -> MyResult<Redirect> {
-    let db2 = (*database).clone();
-    let r = spawn_blocking(move || db2.search_create_index())
-        .await
-        .unwrap();
-    // admin_dashboard(
-    //     database,
-    //     Some(
-    //         r.map_err(|e| e.into())
-    //         .map(|_| "Search index updated".to_string()),
-    //     ),
-    // )
-    // .await
-    Ok(Redirect::temporary(u_admin_dashboard()))
-}
-
-static SEM_TRANSCODING: Semaphore = Semaphore::const_new(1);
-fn is_transcoding() -> bool {
-    SEM_TRANSCODING.available_permits() == 0
-}
-
-#[post("/admin/transcode_posters")]
-pub async fn r_admin_transcode_posters(
-    session: A<AdminSession>,
-    database: &State<Database>,
-) -> MyResult<Redirect> {
-    drop(session);
-    let _permit = SEM_TRANSCODING
-        .try_acquire()
-        .context("transcoding in progress")?;
-
-    let t = Instant::now();
-
-    {
-        let nodes = database.list_nodes_with_udata("")?;
-        for (node, _) in nodes {
-            if let Some(poster) = &node.poster {
-                let asset = AssetInner::deser(&poster.0)?;
-                if asset.is_federated() {
-                    continue;
-                }
-                let source = resolve_asset(asset).await.context("resolving asset")?;
-                jellytranscoder::image::transcode(&source, AVIF_QUALITY, AVIF_SPEED, 1024)
-                    .await
-                    .context("transcoding asset")?;
-            }
-        }
-    }
-    drop(_permit);
-
-    // admin_dashboard(
-    //     database,
-    //     Some(Ok(format!(
-    //         "All posters pre-transcoded; took {:?}",
-    //         t.elapsed()
-    //     ))),
-    // )
-    // .await
+pub async fn r_admin_update_search(session: A<AdminSession>) -> MyResult<Redirect> {
+    update_search_index(&session.0).await?;
     Ok(Redirect::temporary(u_admin_dashboard()))
 }
diff --git a/server/src/ui/admin/user.rs b/server/src/ui/admin/user.rs
index 939ee83..27d5256 100644
--- a/server/src/ui/admin/user.rs
+++ b/server/src/ui/admin/user.rs
@@ -7,25 +7,24 @@ use crate::{
     helper::{language::AcceptLanguage, A},
     ui::error::MyResult,
 };
-use anyhow::{anyhow, Context};
+use anyhow::Context;
 use jellycommon::user::UserPermission;
 use jellyimport::is_importing;
-use jellylogic::{admin::user::admin_users, session::AdminSession, Database};
+use jellylogic::{
+    admin::user::{admin_users, delete_user, get_user, update_user_perms, GrantState},
+    session::AdminSession,
+};
 use jellyui::{
     admin::user::{AdminUserPage, AdminUsersPage},
     render_page,
     scaffold::{RenderInfo, SessionInfo},
 };
-use rocket::{form::Form, get, post, response::content::RawHtml, FromForm, FromFormField, State};
+use rocket::{form::Form, get, post, response::content::RawHtml, FromForm, FromFormField};
 
 #[get("/admin/users")]
-pub fn r_admin_users(
-    session: A<AdminSession>,
-    database: &State<Database>,
-    lang: AcceptLanguage,
-) -> MyResult<RawHtml<String>> {
+pub fn r_admin_users(session: A<AdminSession>, lang: AcceptLanguage) -> MyResult<RawHtml<String>> {
     let AcceptLanguage(lang) = lang;
-    let r = admin_users(database, &session.0)?;
+    let r = admin_users(&session.0)?;
     Ok(RawHtml(render_page(
         &AdminUsersPage {
             flash: None,
@@ -45,14 +44,11 @@ pub fn r_admin_users(
 #[get("/admin/user/<name>")]
 pub fn r_admin_user<'a>(
     session: A<AdminSession>,
-    database: &State<Database>,
     name: &'a str,
     lang: AcceptLanguage,
 ) -> MyResult<RawHtml<String>> {
     let AcceptLanguage(lang) = lang;
-    let user = database
-        .get_user(&name)?
-        .ok_or(anyhow!("user does not exist"))?;
+    let user = get_user(&session.0, name)?;
 
     Ok(RawHtml(render_page(
         &AdminUserPage {
@@ -73,11 +69,11 @@ pub fn r_admin_user<'a>(
 #[derive(FromForm)]
 pub struct UserPermissionForm {
     permission: String,
-    action: GrantState,
+    action: UrlGrantState,
 }
 
 #[derive(FromFormField)]
-pub enum GrantState {
+pub enum UrlGrantState {
     Grant,
     Revoke,
     Unset,
@@ -86,7 +82,6 @@ pub enum GrantState {
 #[post("/admin/user/<name>/update_permission", data = "<form>")]
 pub fn r_admin_user_permission(
     session: A<AdminSession>,
-    database: &State<Database>,
     form: Form<UserPermissionForm>,
     name: &str,
     lang: AcceptLanguage,
@@ -95,18 +90,18 @@ pub fn r_admin_user_permission(
     let perm = serde_json::from_str::<UserPermission>(&form.permission)
         .context("parsing provided permission")?;
 
-    database.update_user(name, |user| {
+    update_user_perms(
+        &session.0,
+        name,
+        perm,
         match form.action {
-            GrantState::Grant => drop(user.permissions.0.insert(perm.clone(), true)),
-            GrantState::Revoke => drop(user.permissions.0.insert(perm.clone(), false)),
-            GrantState::Unset => drop(user.permissions.0.remove(&perm)),
-        }
-        Ok(())
-    })?;
+            UrlGrantState::Grant => GrantState::Grant,
+            UrlGrantState::Revoke => GrantState::Revoke,
+            UrlGrantState::Unset => GrantState::Unset,
+        },
+    )?;
 
-    let user = database
-        .get_user(&name)?
-        .ok_or(anyhow!("user does not exist"))?;
+    let user = get_user(&session.0, name)?;
 
     Ok(RawHtml(render_page(
         &AdminUserPage {
@@ -127,15 +122,12 @@ pub fn r_admin_user_permission(
 #[post("/admin/<name>/remove")]
 pub fn r_admin_remove_user(
     session: A<AdminSession>,
-    database: &State<Database>,
     name: &str,
     lang: AcceptLanguage,
 ) -> MyResult<RawHtml<String>> {
     let AcceptLanguage(lang) = lang;
-    if !database.delete_user(&name)? {
-        Err(anyhow!("user did not exist"))?;
-    }
-    let r = admin_users(database, &session.0)?;
+    delete_user(&session.0, name)?;
+    let r = admin_users(&session.0)?;
 
     Ok(RawHtml(render_page(
         &AdminUsersPage {
diff --git a/server/src/ui/assets.rs b/server/src/ui/assets.rs
index 4e09417..97fd9c7 100644
--- a/server/src/ui/assets.rs
+++ b/server/src/ui/assets.rs
@@ -4,13 +4,19 @@
     Copyright (C) 2025 metamuffin <metamuffin.org>
 */
 use super::error::MyResult;
-use crate::{helper::{cache::CacheControlFile, A}, CONF};
+use crate::{
+    helper::{cache::CacheControlFile, A},
+    CONF,
+};
 use anyhow::{anyhow, bail, Context};
-use jellycommon::{LocalTrack, NodeID, PeopleGroup, SourceTrackKind, TrackSource};
+use jellycommon::{NodeID, PeopleGroup};
 use jellyimport::asset_token::AssetInner;
-use jellylogic::{session::Session, Database};
+use jellylogic::{
+    assets::{get_node_backdrop, get_node_person_asset, get_node_poster, get_node_thumbnail},
+    session::Session,
+};
 use log::info;
-use rocket::{get, http::ContentType, response::Redirect, State};
+use rocket::{get, http::ContentType, response::Redirect};
 use std::path::PathBuf;
 
 pub const AVIF_QUALITY: f32 = 50.;
@@ -25,7 +31,6 @@ pub async fn r_asset(
     let width = width.unwrap_or(2048);
     let asset = AssetInner::deser(token)?;
 
-    let path = 
     // if let AssetInner::Federated { host, asset } = asset {
     //     let session = fed.get_session(&host).await?;
 
@@ -35,7 +40,7 @@ pub async fn r_asset(
     //     })
     //     .await?
     // } else
-    {
+    let path = {
         let source = resolve_asset(asset).await.context("resolving asset")?;
 
         // fit the resolution into a finite set so the maximum cache is finite too.
@@ -62,136 +67,44 @@ pub async fn resolve_asset(asset: AssetInner) -> anyhow::Result<PathBuf> {
 
 #[get("/n/<id>/poster?<width>")]
 pub async fn r_item_poster(
-    _session: A<Session>,
-    db: &State<Database>,
+    session: A<Session>,
     id: A<NodeID>,
     width: Option<usize>,
 ) -> MyResult<Redirect> {
-    // TODO perm
-    let node = db.get_node(id.0)?.ok_or(anyhow!("node does not exist"))?;
-
-    let mut asset = node.poster.clone();
-    if asset.is_none() {
-        if let Some(parent) = node.parents.last().copied() {
-            let parent = db.get_node(parent)?.ok_or(anyhow!("node does not exist"))?;
-            asset = parent.poster.clone();
-        }
-    };
-    let asset = asset.unwrap_or_else(|| {
-        AssetInner::Assets(format!("fallback-{:?}.avif", node.kind).into()).ser()
-    });
+    let asset = get_node_poster(&session.0, id.0)?;
     Ok(Redirect::permanent(rocket::uri!(r_asset(asset.0, width))))
 }
 
 #[get("/n/<id>/backdrop?<width>")]
 pub async fn r_item_backdrop(
-    _session: A<Session>,
-    db: &State<Database>,
+    session: A<Session>,
     id: A<NodeID>,
     width: Option<usize>,
 ) -> MyResult<Redirect> {
-    // TODO perm
-    let node = db.get_node(id.0)?.ok_or(anyhow!("node does not exist"))?;
-
-    let mut asset = node.backdrop.clone();
-    if asset.is_none() {
-        if let Some(parent) = node.parents.last().copied() {
-            let parent = db.get_node(parent)?.ok_or(anyhow!("node does not exist"))?;
-            asset = parent.backdrop.clone();
-        }
-    };
-    let asset = asset.unwrap_or_else(|| {
-        AssetInner::Assets(format!("fallback-{:?}.avif", node.kind).into()).ser()
-    });
+    let asset = get_node_backdrop(&session.0, id.0)?;
     Ok(Redirect::permanent(rocket::uri!(r_asset(asset.0, width))))
 }
 
 #[get("/n/<id>/person/<index>/asset?<group>&<width>")]
 pub async fn r_person_asset(
-    _session: A<Session>,
-    db: &State<Database>,
+    session: A<Session>,
     id: A<NodeID>,
     index: usize,
     group: String,
     width: Option<usize>,
 ) -> MyResult<Redirect> {
-    // TODO perm
-
-    let node = db.get_node(id.0)?.ok_or(anyhow!("node does not exist"))?;
-    let app = node
-        .people
-        .get(&PeopleGroup::from_str_opt(&group).ok_or(anyhow!("unknown people group"))?)
-        .ok_or(anyhow!("group has no members"))?
-        .get(index)
-        .ok_or(anyhow!("person does not exist"))?;
-
-    let asset = app
-        .person
-        .headshot
-        .to_owned()
-        .unwrap_or(AssetInner::Assets("fallback-Person.avif".into()).ser());
+    let group = PeopleGroup::from_str_opt(&group).ok_or(anyhow!("unknown people group"))?;
+    let asset = get_node_person_asset(&session.0, id.0, group, index)?;
     Ok(Redirect::permanent(rocket::uri!(r_asset(asset.0, width))))
 }
 
 #[get("/n/<id>/thumbnail?<t>&<width>")]
 pub async fn r_node_thumbnail(
-    _session: A<Session>,
-    db: &State<Database>,
+    session: A<Session>,
     id: A<NodeID>,
     t: f64,
     width: Option<usize>,
 ) -> MyResult<Redirect> {
-    let node = db.get_node(id.0)?.ok_or(anyhow!("node does not exist"))?;
-
-    let media = node.media.as_ref().ok_or(anyhow!("no media"))?;
-    let (thumb_track_index, _thumb_track) = media
-        .tracks
-        .iter()
-        .enumerate()
-        .find(|(_i, t)| matches!(t.kind, SourceTrackKind::Video { .. }))
-        .ok_or(anyhow!("no video track to create a thumbnail of"))?;
-    let source = media
-        .tracks
-        .get(thumb_track_index)
-        .ok_or(anyhow!("no source"))?;
-    let thumb_track_source = source.source.clone();
-
-    if t < 0. || t > media.duration {
-        Err(anyhow!("thumbnail instant not within media duration"))?
-    }
-
-    let step = 8.;
-    let t = (t / step).floor() * step;
-
-    let asset = match thumb_track_source {
-        TrackSource::Local(a) => {
-            let AssetInner::LocalTrack(LocalTrack { path, .. }) = AssetInner::deser(&a.0)? else {
-                return Err(anyhow!("track set to wrong asset type").into());
-            };
-            // the track selected might be different from thumb_track
-            jellytranscoder::thumbnail::create_thumbnail(&path, t).await?
-        }
-        TrackSource::Remote(_) => {
-            // // TODO in the new system this is preferrably a property of node ext for regular fed
-            // let session = fed
-            //     .get_session(
-            //         thumb_track
-            //             .federated
-            //             .last()
-            //             .ok_or(anyhow!("federation broken"))?,
-            //     )
-            //     .await?;
-
-            // async_cache_file("fed-thumb", (id.0, t as i64), |out| {
-            //     session.node_thumbnail(out, id.0.into(), 2048, t)
-            // })
-            // .await?
-            todo!()
-        }
-    };
-
-    Ok(Redirect::temporary(rocket::uri!(r_asset(
-        AssetInner::Cache(asset).ser().0,
-        width
-    ))))
+    let asset = get_node_thumbnail(&session.0, id.0, t).await?;
+    Ok(Redirect::temporary(rocket::uri!(r_asset(asset.0, width))))
 }
diff --git a/server/src/ui/home.rs b/server/src/ui/home.rs
index 555b654..4a423cf 100644
--- a/server/src/ui/home.rs
+++ b/server/src/ui/home.rs
@@ -8,24 +8,23 @@ use super::error::MyResult;
 use crate::helper::{accept::AcceptJson, language::AcceptLanguage, A};
 use jellycommon::api::ApiHomeResponse;
 use jellyimport::is_importing;
-use jellylogic::{session::Session, Database};
+use jellylogic::session::Session;
 use jellyui::{
     home::HomePage,
     render_page,
     scaffold::{RenderInfo, SessionInfo},
 };
-use rocket::{get, response::content::RawHtml, serde::json::Json, Either, State};
+use rocket::{get, response::content::RawHtml, serde::json::Json, Either};
 
 #[get("/home")]
 pub fn r_home(
     session: A<Session>,
-    db: &State<Database>,
     aj: AcceptJson,
     lang: AcceptLanguage,
 ) -> MyResult<Either<RawHtml<String>, Json<ApiHomeResponse>>> {
     let AcceptLanguage(lang) = lang;
 
-    let r = jellylogic::home::home(&db, &session.0)?;
+    let r = jellylogic::home::home(&session.0)?;
 
     Ok(if *aj {
         Either::Right(Json(r))
diff --git a/server/src/ui/items.rs b/server/src/ui/items.rs
index ed16c61..1ac2c09 100644
--- a/server/src/ui/items.rs
+++ b/server/src/ui/items.rs
@@ -7,18 +7,17 @@ use super::error::MyError;
 use crate::helper::{accept::AcceptJson, language::AcceptLanguage, A};
 use jellycommon::api::{ApiItemsResponse, NodeFilterSort};
 use jellyimport::is_importing;
-use jellylogic::{items::all_items, session::Session, Database};
+use jellylogic::{items::all_items, session::Session};
 use jellyui::{
     items::ItemsPage,
     render_page,
     scaffold::{RenderInfo, SessionInfo},
 };
-use rocket::{get, response::content::RawHtml, serde::json::Json, Either, State};
+use rocket::{get, response::content::RawHtml, serde::json::Json, Either};
 
 #[get("/items?<page>&<filter..>")]
 pub fn r_items(
     session: A<Session>,
-    db: &State<Database>,
     aj: AcceptJson,
     page: Option<usize>,
     filter: A<NodeFilterSort>,
@@ -26,7 +25,7 @@ pub fn r_items(
 ) -> Result<Either<RawHtml<String>, Json<ApiItemsResponse>>, MyError> {
     let AcceptLanguage(lang) = lang;
 
-    let r = all_items(db, &session.0, page, filter.0.clone())?;
+    let r = all_items(&session.0, page, filter.0.clone())?;
 
     Ok(if *aj {
         Either::Right(Json(r))
diff --git a/server/src/ui/node.rs b/server/src/ui/node.rs
index 00445a9..0b1a92f 100644
--- a/server/src/ui/node.rs
+++ b/server/src/ui/node.rs
@@ -10,19 +10,18 @@ use jellycommon::{
     NodeID,
 };
 use jellyimport::is_importing;
-use jellylogic::{node::get_node, session::Session, Database};
+use jellylogic::{node::get_node, session::Session};
 use jellyui::{
     node_page::NodePage,
     render_page,
     scaffold::{RenderInfo, SessionInfo},
 };
-use rocket::{get, response::content::RawHtml, serde::json::Json, Either, State};
+use rocket::{get, response::content::RawHtml, serde::json::Json, Either};
 
 #[get("/n/<id>?<parents>&<children>&<filter..>")]
 pub async fn r_node<'a>(
     session: A<Session>,
     id: A<NodeID>,
-    db: &'a State<Database>,
     aj: AcceptJson,
     filter: Option<A<NodeFilterSort>>,
     lang: AcceptLanguage,
@@ -33,9 +32,8 @@ pub async fn r_node<'a>(
     let filter = filter.unwrap_or_default();
 
     let r = get_node(
-        &db,
-        id.0,
         &session.0,
+        id.0,
         !*aj || children,
         !*aj || parents,
         filter.0.clone(),
diff --git a/server/src/ui/player.rs b/server/src/ui/player.rs
index 1fd9e07..ae4468d 100644
--- a/server/src/ui/player.rs
+++ b/server/src/ui/player.rs
@@ -15,7 +15,7 @@ use jellycommon::{
     NodeID,
 };
 use jellyimport::is_importing;
-use jellylogic::{node::get_node, session::Session, Database};
+use jellylogic::{node::get_node, session::Session};
 use jellyui::{
     node_page::NodePage,
     render_page,
@@ -24,7 +24,7 @@ use jellyui::{
 use rocket::{
     get,
     response::{content::RawHtml, Redirect},
-    Either, State,
+    Either,
 };
 use std::time::Duration;
 
@@ -46,20 +46,12 @@ fn jellynative_url(action: &str, seek: f64, secret: &str, node: &str, session: &
 pub fn r_player(
     session: A<Session>,
     lang: AcceptLanguage,
-    db: &State<Database>,
     t: Option<f64>,
     id: A<NodeID>,
 ) -> MyResult<Either<RawHtml<String>, Redirect>> {
     let AcceptLanguage(lang) = lang;
 
-    let r = get_node(
-        &db,
-        id.0,
-        &session.0,
-        false,
-        true,
-        NodeFilterSort::default(),
-    )?;
+    let r = get_node(&session.0, id.0, false, true, NodeFilterSort::default())?;
 
     let native_session = |action: &str| {
         Ok(Either::Right(Redirect::temporary(jellynative_url(
diff --git a/server/src/ui/search.rs b/server/src/ui/search.rs
index 750c8bd..e4afdd8 100644
--- a/server/src/ui/search.rs
+++ b/server/src/ui/search.rs
@@ -8,18 +8,17 @@ use crate::helper::{accept::AcceptJson, language::AcceptLanguage, A};
 use anyhow::anyhow;
 use jellycommon::api::ApiSearchResponse;
 use jellyimport::is_importing;
-use jellylogic::{search::search, session::Session, Database};
+use jellylogic::{search::search, session::Session};
 use jellyui::{
     render_page,
     scaffold::{RenderInfo, SessionInfo},
     search::SearchPage,
 };
-use rocket::{get, response::content::RawHtml, serde::json::Json, Either, State};
+use rocket::{get, response::content::RawHtml, serde::json::Json, Either};
 
 #[get("/search?<query>&<page>")]
 pub async fn r_search<'a>(
     session: A<Session>,
-    db: &State<Database>,
     aj: AcceptJson,
     query: Option<&str>,
     page: Option<usize>,
@@ -28,7 +27,7 @@ pub async fn r_search<'a>(
     let AcceptLanguage(lang) = lang;
 
     let r = query
-        .map(|query| search(db, &session.0, query, page))
+        .map(|query| search(&session.0, query, page))
         .transpose()?;
 
     Ok(if *aj {
diff --git a/server/src/ui/stats.rs b/server/src/ui/stats.rs
index b6e9321..4ae592e 100644
--- a/server/src/ui/stats.rs
+++ b/server/src/ui/stats.rs
@@ -7,23 +7,22 @@ use super::error::MyError;
 use crate::helper::{accept::AcceptJson, language::AcceptLanguage, A};
 use jellycommon::api::ApiStatsResponse;
 use jellyimport::is_importing;
-use jellylogic::{session::Session, stats::stats, Database};
+use jellylogic::{session::Session, stats::stats};
 use jellyui::{
     render_page,
     scaffold::{RenderInfo, SessionInfo},
     stats::StatsPage,
 };
-use rocket::{get, response::content::RawHtml, serde::json::Json, Either, State};
+use rocket::{get, response::content::RawHtml, serde::json::Json, Either};
 
 #[get("/stats")]
 pub fn r_stats(
     session: A<Session>,
-    db: &State<Database>,
     aj: AcceptJson,
     lang: AcceptLanguage,
 ) -> Result<Either<RawHtml<String>, Json<ApiStatsResponse>>, MyError> {
     let AcceptLanguage(lang) = lang;
-    let r = stats(db, &session.0)?;
+    let r = stats(&session.0)?;
 
     Ok(if *aj {
         Either::Right(Json(r))