chore: bump deps; fix clippy lints & cleanup

Signed-off-by: NotAShelf <raf@notashelf.dev>
Change-Id: I4c4815ad145650a07f108614034d2e996a6a6964

crates/pinakes-server/src/routes/media.rs

@@ -836,8 +836,6 @@ pub async fn get_media_count(
   Ok(Json(MediaCountResponse { count }))
 }
 
-// ===== File Management Endpoints =====
-
 pub async fn rename_media(
   State(state): State<AppState>,
   Path(id): Path<Uuid>,
@@ -978,8 +976,6 @@ pub async fn batch_move_media(
   }
 }
 
-// ===== Trash Endpoints =====
-
 pub async fn soft_delete_media(
   State(state): State<AppState>,
   Path(id): Path<Uuid>,

crates/pinakes-server/src/routes/notes.rs

@@ -25,8 +25,6 @@ use uuid::Uuid;
 
 use crate::{error::ApiError, state::AppState};
 
-// ===== Response DTOs =====
-
 /// Response for backlinks query
 #[derive(Debug, Serialize)]
 pub struct BacklinksResponse {
@@ -200,8 +198,6 @@ pub struct UnresolvedLinksResponse {
   pub count: u64,
 }
 
-// ===== Handlers =====
-
 /// Get backlinks (incoming links) to a media item.
 ///
 /// GET /api/v1/media/{id}/backlinks

crates/pinakes-server/src/routes/shares.rs

@@ -93,7 +93,12 @@ pub async fn create_share(
   let recipient = match req.recipient_type.as_str() {
     "public_link" => {
       let token = generate_share_token();
-      let password_hash = req.password.as_ref().map(|p| hash_share_password(p));
+      let password_hash = req
+        .password
+        .as_ref()
+        .map(|p| hash_share_password(p))
+        .transpose()
+        .map_err(ApiError)?;
       ShareRecipient::PublicLink {
         token,
         password_hash,
@@ -409,35 +414,37 @@ pub async fn access_shared(
     .map_err(|e| ApiError::not_found(format!("Share not found: {}", e)))?;
 
   // Check expiration
-  if let Some(expires_at) = share.expires_at {
-    if Utc::now() > expires_at {
-      return Err(ApiError::not_found("Share has expired"));
-    }
+  if let Some(expires_at) = share.expires_at
+    && Utc::now() > expires_at
+  {
+    return Err(ApiError::not_found("Share has expired"));
   }
 
   // Check password if required
-  if let ShareRecipient::PublicLink { password_hash, .. } = &share.recipient {
-    if let Some(hash) = password_hash {
-      let provided_password = params
-        .password
-        .as_ref()
-        .ok_or_else(|| ApiError::unauthorized("Password required"))?;
+  if let ShareRecipient::PublicLink {
+    password_hash: Some(hash),
+    ..
+  } = &share.recipient
+  {
+    let provided_password = params
+      .password
+      .as_ref()
+      .ok_or_else(|| ApiError::unauthorized("Password required"))?;
 
-      if !verify_share_password(provided_password, hash) {
-        // Log failed attempt
-        let activity = ShareActivity {
-          id:        Uuid::now_v7(),
-          share_id:  share.id,
-          actor_id:  None,
-          actor_ip:  Some(addr.ip().to_string()),
-          action:    ShareActivityAction::PasswordFailed,
-          details:   None,
-          timestamp: Utc::now(),
-        };
-        let _ = state.storage.record_share_activity(&activity).await;
+    if !verify_share_password(provided_password, hash) {
+      // Log failed attempt
+      let activity = ShareActivity {
+        id:        Uuid::now_v7(),
+        share_id:  share.id,
+        actor_id:  None,
+        actor_ip:  Some(addr.ip().to_string()),
+        action:    ShareActivityAction::PasswordFailed,
+        details:   None,
+        timestamp: Utc::now(),
+      };
+      let _ = state.storage.record_share_activity(&activity).await;
 
-        return Err(ApiError::unauthorized("Invalid password"));
-      }
+      return Err(ApiError::unauthorized("Invalid password"));
     }
   }
 
@@ -473,8 +480,6 @@ pub async fn access_shared(
       Ok(Json(item.into()))
     },
     _ => {
-      // For collections/tags, return a placeholder
-      // Full implementation would return the collection contents
       Err(ApiError::bad_request(
         "Collection/tag sharing not yet fully implemented",
       ))

crates/pinakes-server/src/routes/social.rs

@@ -13,8 +13,6 @@ pub struct ShareLinkQuery {
   pub password: Option<String>,
 }
 
-// ===== Ratings =====
-
 pub async fn rate_media(
   State(state): State<AppState>,
   Extension(username): Extension<String>,
@@ -46,8 +44,6 @@ pub async fn get_media_ratings(
   ))
 }
 
-// ===== Comments =====
-
 pub async fn add_comment(
   State(state): State<AppState>,
   Extension(username): Extension<String>,
@@ -80,8 +76,6 @@ pub async fn get_media_comments(
   ))
 }
 
-// ===== Favorites =====
-
 pub async fn add_favorite(
   State(state): State<AppState>,
   Extension(username): Extension<String>,
@@ -120,8 +114,6 @@ pub async fn list_favorites(
   Ok(Json(items.into_iter().map(MediaResponse::from).collect()))
 }
 
-// ===== Share Links =====
-
 pub async fn create_share_link(
   State(state): State<AppState>,
   Extension(username): Extension<String>,

crates/pinakes-server/src/routes/sync.rs

@@ -301,7 +301,7 @@ pub async fn report_changes(
   if !config.sync.enabled {
     return Err(ApiError::bad_request("Sync is not enabled"));
   }
-  let conflict_resolution = config.sync.default_conflict_resolution.clone();
+  let conflict_resolution = config.sync.default_conflict_resolution;
   drop(config);
 
   let mut accepted = Vec::new();
@@ -514,7 +514,7 @@ pub async fn create_upload(
     .ok_or_else(|| ApiError::unauthorized("Invalid device token"))?;
 
   let chunk_size = req.chunk_size.unwrap_or(DEFAULT_CHUNK_SIZE);
-  let chunk_count = (req.expected_size + chunk_size - 1) / chunk_size;
+  let chunk_count = req.expected_size.div_ceil(chunk_size);
   let now = Utc::now();
 
   let session = UploadSession {
@@ -784,10 +784,10 @@ pub async fn cancel_upload(
     })?;
 
   // Clean up temp file if manager is available
-  if let Some(ref manager) = state.chunked_upload_manager {
-    if let Err(e) = manager.cancel(id).await {
-      tracing::warn!(session_id = %id, error = %e, "failed to clean up temp file");
-    }
+  if let Some(ref manager) = state.chunked_upload_manager
+    && let Err(e) = manager.cancel(id).await
+  {
+    tracing::warn!(session_id = %id, error = %e, "failed to clean up temp file");
   }
 
   session.status = UploadStatus::Cancelled;
@@ -827,38 +827,37 @@ pub async fn download_file(
   let file_size = metadata.len();
 
   // Check for Range header
-  if let Some(range_header) = headers.get(header::RANGE) {
-    if let Ok(range_str) = range_header.to_str() {
-      if let Some(range) = parse_range_header(range_str, file_size) {
-        // Partial content response
-        let (start, end) = range;
-        let length = end - start + 1;
+  if let Some(range_header) = headers.get(header::RANGE)
+    && let Ok(range_str) = range_header.to_str()
+    && let Some(range) = parse_range_header(range_str, file_size)
+  {
+    // Partial content response
+    let (start, end) = range;
+    let length = end - start + 1;
 
-        let file = tokio::fs::File::open(&item.path).await.map_err(|e| {
-          ApiError::internal(format!("Failed to reopen file: {}", e))
-        })?;
+    let file = tokio::fs::File::open(&item.path).await.map_err(|e| {
+      ApiError::internal(format!("Failed to reopen file: {}", e))
+    })?;
 
-        let stream = ReaderStream::new(file);
-        let body = Body::from_stream(stream);
+    let stream = ReaderStream::new(file);
+    let body = Body::from_stream(stream);
 
-        return Ok(
+    return Ok(
+      (
+        StatusCode::PARTIAL_CONTENT,
+        [
+          (header::CONTENT_TYPE, item.media_type.mime_type()),
+          (header::CONTENT_LENGTH, length.to_string()),
           (
-            StatusCode::PARTIAL_CONTENT,
-            [
-              (header::CONTENT_TYPE, item.media_type.mime_type()),
-              (header::CONTENT_LENGTH, length.to_string()),
-              (
-                header::CONTENT_RANGE,
-                format!("bytes {}-{}/{}", start, end, file_size),
-              ),
-              (header::ACCEPT_RANGES, "bytes".to_string()),
-            ],
-            body,
-          )
-            .into_response(),
-        );
-      }
-    }
+            header::CONTENT_RANGE,
+            format!("bytes {}-{}/{}", start, end, file_size),
+          ),
+          (header::ACCEPT_RANGES, "bytes".to_string()),
+        ],
+        body,
+      )
+        .into_response(),
+    );
   }
 
   // Full content response