refactor: replace GroupMediaDownload with RsGroupDownload from shared interfaces

BREAKING CHANGE: The /libraries/:id/medias/download endpoint now expects
RsGroupDownload instead of GroupMediaDownload<MediaDownloadUrl>.

## What changed

- Removed `GroupMediaDownload<T>` and `MediaDownloadUrl` structs
- Now uses `RsGroupDownload` and `RsRequest` from rs-plugin-common-interfaces
- Added new lookup fields: `tags_lookup`, `people_lookup`, `albums_lookup`
  (separate from direct ID fields `tags`, `people`, `albums`)
- Bumped rs-plugin-common-interfaces to 0.20.4

## Migration Guide

### Before (TypeScript)
```typescript
interface MediaDownloadUrl {
  url: string;
  parse: boolean;
  uploadId?: string;
  ignoreOriginDuplicate?: boolean;
  kind?: 'photo' | 'video' | 'archive' | 'album' | 'other';
  filename?: string;
  mime?: string;
  description?: string;
  length?: number;
  thumbnailUrl?: string;
  peopleLookup?: string[];
  seriesLookup?: string[];
  tagsLookup?: string[];
  season?: number;
  episode?: number;
}

interface GroupMediaDownload {
  group?: boolean;
  groupThumbnailUrl?: string;
  groupFilename?: string;
  groupMime?: string;
  files: MediaDownloadUrl[];
  referer?: string;
  headers?: string[];  // "Name:Value" format
  cookies?: string[];
  originUrl?: string;
  title?: string;
  ignoreOriginDuplicate?: boolean;
  description?: string;
  peopleLookup?: string[];
  seriesLookup?: string[];
  tagsLookup?: string[];
  season?: number;
  episode?: number;
}

// Old usage
const download: GroupMediaDownload = {
  files: [{
    url: 'https://example.com/image.jpg',
    parse: false,
    peopleLookup: ['John Doe'],
    tagsLookup: ['vacation']
  }],
  originUrl: 'https://example.com/post/123'
};
```

### After (TypeScript)
```typescript
interface RsRequest {
  url: string;
  uploadId?: string;
  mime?: string;
  size?: number;
  filename?: string;
  status?: 'unprocessed' | 'needParsing' | 'finalPublic' | 'finalPrivate';
  referer?: string;
  headers?: [string, string][];  // Tuple array format
  cookies?: RsCookie[];
  description?: string;
  ignoreOriginDuplicate?: boolean;
  // New lookup fields (text to search in DB)
  tagsLookup?: string[];
  peopleLookup?: string[];
  albumsLookup?: string[];  // renamed from seriesLookup
  // New download fields
  thumbnailUrl?: string;
  originUrl?: string;
  title?: string;
  kind?: 'photo' | 'video' | 'archive' | 'album' | 'other';
  season?: number;
  episode?: number;
}

interface RsGroupDownload {
  group: boolean;  // Now required, not optional
  groupThumbnailUrl?: string;
  groupFilename?: string;
  groupMime?: string;
  requests: RsRequest[];  // renamed from 'files'
}

// New usage - info moved to individual requests
const download: RsGroupDownload = {
  group: false,
  requests: [{
    url: 'https://example.com/image.jpg',
    status: 'unprocessed',  // replaces parse: false
    peopleLookup: ['John Doe'],
    tagsLookup: ['vacation'],
    originUrl: 'https://example.com/post/123'  // moved to request
  }]
};

// For grouped downloads
const groupedDownload: RsGroupDownload = {
  group: true,
  groupFilename: 'my-album.zip',
  groupThumbnailUrl: 'https://example.com/thumb.jpg',
  requests: [
    { url: 'https://example.com/1.jpg', status: 'unprocessed' },
    { url: 'https://example.com/2.jpg', status: 'unprocessed' }
  ]
};
```

## Key differences

1. `files` renamed to `requests`
2. `parse: true` becomes `status: 'needParsing'`
3. `parse: false` becomes `status: 'unprocessed'`
4. `seriesLookup` renamed to `albumsLookup`
5. Group-level `originUrl`, `referer`, `headers`, `cookies` moved to individual requests
6. `headers` format changed from `["Name:Value"]` to `[["Name", "Value"]]`
7. `cookies` now uses structured `RsCookie` objects instead of strings

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: neckaros

Cargo.lock

@@ -74,7 +74,7 @@ sha256 = "1.5.0"
 axum-extra = { version = "0.9.2", features = ["query"] }
 http = "1.1.0"
 extism = "1.10.0"
-rs-plugin-common-interfaces = { version = "0.20.3", features = ["rusqlite",] }
+rs-plugin-common-interfaces = { version = "0.20.4", features = ["rusqlite",] }
 async-recursion = "1.1.0"
 async-compression = { version = "0.4.6", features = ["tokio"] }
 youtube_dl = { version = "0.10.0", features = ["tokio", "downloader-rustls-tls"] }

Cargo.toml

@@ -440,139 +440,6 @@ impl MediaForAdd {
     }
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone)]
-#[serde(rename_all = "camelCase")]
-pub struct GroupMediaDownload<T> {
-    pub group: Option<bool>,
-    pub group_thumbnail_url: Option<String>,
-    pub group_filename: Option<String>,
-    pub group_mime: Option<String>,
-    pub files: Vec<T>,
-
-    pub referer: Option<String>,
-    pub headers: Option<Vec<String>>,
-    pub cookies: Option<Vec<String>>,
-    pub origin_url: Option<String>,
-
-    pub title: Option<String>,
-
-    pub ignore_origin_duplicate: Option<bool>,
-
-    pub description: Option<String>,
-    pub people_lookup: Option<Vec<String>>,
-    pub series_lookup: Option<Vec<String>>,
-    pub tags_lookup: Option<Vec<String>>,
-    pub season: Option<u32>,
-    pub episode: Option<u32>,
-}
-impl<T> GroupMediaDownload<T> {
-    pub fn headers_as_tuple(&self) -> Option<Vec<(String, String)>> {
-        if let Some(headers) = &self.headers {
-            headers
-                .iter()
-                .map(|v| {
-                    let splitted: Vec<&str> = v.split(':').collect();
-                    let result =
-                        if let (Some(name), Some(value)) = (splitted.get(0), splitted.get(1)) {
-                            Some((name.to_string(), value.to_string()))
-                        } else {
-                            None
-                        };
-                    return result;
-                })
-                .collect()
-        } else {
-            None
-        }
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize, Clone)]
-#[serde(rename_all = "camelCase")]
-pub struct MediaDownloadUrl {
-    pub url: String,
-    pub parse: bool,
-    pub upload_id: Option<String>,
-
-    #[serde(default)]
-    pub ignore_origin_duplicate: bool,
-    //pub infos: Option<MediaForUpdate>,
-    pub kind: Option<FileType>,
-    pub filename: Option<String>,
-    pub mime: Option<String>,
-    pub description: Option<String>,
-    pub length: Option<u64>,
-    pub thumbnail_url: Option<String>,
-
-    pub people_lookup: Option<Vec<String>>,
-    pub series_lookup: Option<Vec<String>>,
-    pub tags_lookup: Option<Vec<String>>,
-    pub season: Option<i32>,
-    pub episode: Option<i32>,
-}
-
-impl From<MediaDownloadUrl> for RsRequest {
-    fn from(value: MediaDownloadUrl) -> Self {
-        RsRequest {
-            url: value.url,
-            mime: value.mime,
-            size: None,
-            filename: value.filename,
-            status: if value.parse {
-                RsRequestStatus::NeedParsing
-            } else {
-                RsRequestStatus::Unprocessed
-            },
-            headers: None,
-            cookies: None,
-            files: None,
-            selected_file: None,
-            tags: value.tags_lookup,
-            albums: value.series_lookup,
-            people: value.people_lookup,
-            ignore_origin_duplicate: value.ignore_origin_duplicate,
-            ..Default::default()
-        }
-    }
-}
-
-impl From<GroupMediaDownload<MediaDownloadUrl>> for Vec<RsRequest> {
-    fn from(value: GroupMediaDownload<MediaDownloadUrl>) -> Self {
-        let headers = value.headers_as_tuple();
-        //println!("Headers parsed {:?}", headers);
-        let mut output = Vec::new();
-        for file in value.files {
-            output.push(RsRequest {
-                upload_id: file.upload_id,
-                url: file.url,
-                mime: None,
-                size: None,
-                filename: file.filename,
-                status: if file.parse {
-                    RsRequestStatus::NeedParsing
-                } else {
-                    RsRequestStatus::Unprocessed
-                },
-                headers: headers.clone(),
-                cookies: value
-                    .cookies
-                    .as_ref()
-                    .and_then(|c| c.iter().map(|s| RsCookie::from_str(s).ok()).collect()),
-                files: None,
-                selected_file: None,
-                referer: value.referer.clone(),
-                tags: file.tags_lookup.or(value.tags_lookup.clone()),
-                albums: file.series_lookup.or(value.series_lookup.clone()),
-                people: file.people_lookup.or(value.people_lookup.clone()),
-                description: file.description.or(value.title.clone()),
-                ignore_origin_duplicate: file.ignore_origin_duplicate,
-                ..Default::default()
-            });
-        }
-        output
-    }
-}
-
 impl From<Media> for MediaForAdd {
     fn from(value: Media) -> Self {
         MediaForAdd {
@@ -621,61 +488,15 @@ impl From<RsRequest> for MediaForUpdate {
             name: value.filename_or_extract_from_url(),
             description: value.description,
             ignore_origin_duplicate: value.ignore_origin_duplicate,
-            //kind: value.k,
             size: value.size,
-            people_lookup: value.people,
-            tags_lookup: value.tags,
-            series_lookup: value.albums,
-            ..Default::default()
-        }
-    }
-}
-
-impl From<GroupMediaDownload<MediaDownloadUrl>> for MediaForUpdate {
-    fn from(value: GroupMediaDownload<MediaDownloadUrl>) -> Self {
-        let mut update = MediaForUpdate {
-            name: value.group_filename,
-            description: value.description,
-            ignore_origin_duplicate: value.ignore_origin_duplicate.unwrap_or_default(),
+            // Use the new lookup fields for database text search
             people_lookup: value.people_lookup,
             tags_lookup: value.tags_lookup,
-            series_lookup: value.series_lookup,
+            series_lookup: value.albums_lookup,
             season: value.season,
             episode: value.episode,
             ..Default::default()
-        };
-
-        if value.group.unwrap_or_default() {
-            let mut people_final = update.people_lookup.clone().unwrap_or_default();
-            for file in &value.files {
-                if let Some(people) = &file.people_lookup {
-                    for person in people {
-                        if !people_final.contains(person) {
-                            people_final.push(person.to_string());
-                        }
-                    }
-                }
-            }
-            if !people_final.is_empty() {
-                update.people_lookup = Some(people_final);
-            }
-
-            let mut tags_final = update.tags_lookup.clone().unwrap_or_default();
-            for file in &value.files {
-                if let Some(tags) = &file.tags_lookup {
-                    for tag in tags {
-                        if !tags_final.contains(tag) {
-                            tags_final.push(tag.to_string());
-                        }
-                    }
-                }
-            }
-            if !tags_final.is_empty() {
-                update.tags_lookup = Some(tags_final);
-            }
         }
-
-        update
     }
 }
 

src/domain/media.rs

@@ -13,7 +13,7 @@ use mime_guess::get_mime_extensions_str;
 use nanoid::nanoid;
 use query_external_ip::SourceError;
 use regex::Regex;
-use rs_plugin_common_interfaces::{request::{RsRequest, RsRequestStatus}, url::{RsLink, RsLinkType}, video::{RsVideoTranscodeJob, RsVideoTranscodeJobPluginRequest, RsVideoTranscodeStatus, VideoConvertRequest, VideoOverlayType}, PluginType, RsCookie};
+use rs_plugin_common_interfaces::{request::{RsGroupDownload, RsRequest, RsRequestStatus}, url::{RsLink, RsLinkType}, video::{RsVideoTranscodeJob, RsVideoTranscodeJobPluginRequest, RsVideoTranscodeStatus, VideoConvertRequest, VideoOverlayType}, PluginType, RsCookie};
 use rusqlite::{types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef}, ToSql};
 use serde::{Deserialize, Serialize};
 use strum_macros::EnumString;
@@ -24,7 +24,7 @@ use zip::ZipWriter;
 
 use crate::{domain::{MediaElement, deleted::RsDeleted, library::LibraryType, media::{self, ConvertMessage, ConvertProgress, DEFAULT_MIME, RsGpsPosition}, plugin}, error::RsError, model::store::sql::SqlOrder, plugins::sources::{Source, path_provider::PathProvider}, routes::infos, server::get_config, tools::{file_tools::{filename_from_path, remove_extension}, image_tools::{IMAGES_MIME_FULL_BROWSER_SUPPORT, convert_image_reader, image_infos}, recognition, video_tools::VideoCommandBuilder}};
 
-use crate::{domain::{library::LibraryRole, media::{FileType, GroupMediaDownload, Media, MediaDownloadUrl, MediaForAdd, MediaForInsert, MediaForUpdate, MediaItemReference, MediaWithAction, MediasMessage, ProgressMessage}, progress::{RsProgress, RsProgressType}, ElementAction}, error::RsResult, plugins::{get_plugin_fodler, sources::{async_reader_progress::ProgressReader, error::SourcesError, AsyncReadPinBox, FileStreamResult, SourceRead}}, routes::mw_range::RangeDefinition, server::get_server_port, tools::{auth::{sign_local, ClaimsLocal}, file_tools::{file_type_from_mime, get_extension_from_mime}, image_tools::{self, resize_image_reader, ImageSize}, log::{log_error, log_warn, log_info, LogServiceType}, prediction::{predict_net, preload_model, PredictionTagResult}, video_tools::{self, probe_video, VideoTime}}};
+use crate::{domain::{library::LibraryRole, media::{FileType, Media, MediaForAdd, MediaForInsert, MediaForUpdate, MediaItemReference, MediaWithAction, MediasMessage, ProgressMessage}, progress::{RsProgress, RsProgressType}, ElementAction}, error::RsResult, plugins::{get_plugin_fodler, sources::{async_reader_progress::ProgressReader, error::SourcesError, AsyncReadPinBox, FileStreamResult, SourceRead}}, routes::mw_range::RangeDefinition, server::get_server_port, tools::{auth::{sign_local, ClaimsLocal}, file_tools::{file_type_from_mime, get_extension_from_mime}, image_tools::{self, resize_image_reader, ImageSize}, log::{log_error, log_warn, log_info, LogServiceType}, prediction::{predict_net, preload_model, PredictionTagResult}, video_tools::{self, probe_video, VideoTime}}};
 
 use super::{error::{Error, Result}, plugins::PluginQuery, store::{self, sql::library::medias::MediaBackup}, users::ConnectedUser, ModelController, VideoConvertQueueElement};
 use crate::routes::sse::SseEvent;
@@ -180,6 +180,28 @@ impl TryFrom<Media> for MediaSource {
 
 impl ModelController {
 
+    /// Helper to aggregate lookup fields from multiple requests into a single deduplicated list
+    fn aggregate_lookup_field<F>(requests: &[RsRequest], getter: F) -> Option<Vec<String>>
+    where
+        F: Fn(&RsRequest) -> Option<Vec<String>>,
+    {
+        let mut result: Vec<String> = Vec::new();
+        for request in requests {
+            if let Some(values) = getter(request) {
+                for value in values {
+                    if !result.contains(&value) {
+                        result.push(value);
+                    }
+                }
+            }
+        }
+        if result.is_empty() {
+            None
+        } else {
+            Some(result)
+        }
+    }
+
 	pub async fn get_medias(&self, library_id: &str, query: MediaQuery, requesting_user: &ConnectedUser) -> RsResult<Vec<Media>> {
         let progress_user = self.get_library_mapped_user(library_id, requesting_user.user_id()?).await.ok();
         let mut limits = requesting_user.check_library_role(library_id, LibraryRole::Read)?;
@@ -655,36 +677,52 @@ impl ModelController {
 	}
 
 
-    pub async fn download_library_url(&self, library_id: &str, files: GroupMediaDownload<MediaDownloadUrl>, requesting_user: &ConnectedUser) -> RsResult<Vec<Media>> {
+    pub async fn download_library_url(&self, library_id: &str, files: RsGroupDownload, requesting_user: &ConnectedUser) -> RsResult<Vec<Media>> {
 
         requesting_user.check_library_role(library_id, LibraryRole::Write)?;
         self.cache_check_library_notcrypt(library_id).await?;
 
         let m = self.source_for_library(library_id).await?;
         let store = self.store.get_library_store(library_id)?;
         let mut medias: Vec<Media> = vec![];
-        let origin = if let Some(origin) = &files.origin_url {
+
+        // Get group-level info from the first request
+        let first_request = files.requests.first();
+        let origin_url = first_request.and_then(|r| r.origin_url.clone());
+        let origin = if let Some(origin) = &origin_url {
             Some(self.exec_parse(Some(library_id.to_owned()), origin.to_owned(), requesting_user).await.ok().unwrap_or(RsLink {platform: "link".to_owned(), kind: Some(RsLinkType::Post), id: origin.to_owned(), ..Default::default()}))
         } else {
             None
         };
 
 
-        if files.group.unwrap_or_default() {
+        if files.group {
             let thumbnail = files.group_thumbnail_url.clone();
-            let mut infos: MediaForUpdate = files.clone().into();
+            // Build MediaForUpdate from group data and first request
+            let mut infos = MediaForUpdate {
+                name: files.group_filename.clone(),
+                mimetype: files.group_mime.clone(),
+                // Aggregate lookup fields from all requests
+                people_lookup: Self::aggregate_lookup_field(&files.requests, |r| r.people_lookup.clone()),
+                tags_lookup: Self::aggregate_lookup_field(&files.requests, |r| r.tags_lookup.clone()),
+                series_lookup: Self::aggregate_lookup_field(&files.requests, |r| r.albums_lookup.clone()),
+                ignore_origin_duplicate: first_request.map(|r| r.ignore_origin_duplicate).unwrap_or_default(),
+                season: first_request.and_then(|r| r.season),
+                episode: first_request.and_then(|r| r.episode),
+                ..Default::default()
+            };
             infos.origin = origin.clone();
 
             let mut medias: Vec<Media> = vec![];
-            let requests: Vec<RsRequest> = files.clone().into(); 
+            let requests = files.requests.clone(); 
 
             let upload_id = nanoid!();
             //Progress
             let tx_progress = self.create_progress_sender(library_id.to_owned(), Some(upload_id.clone()));
 
 
             if let Some(origin) = &mut infos.origin {
-                let origin_filename = if let Some(origin_url) = files.origin_url.clone() { filename_from_path(&origin_url) } else { None };
+                let origin_filename = if let Some(origin_url) = origin_url.clone() { filename_from_path(&origin_url) } else { None };
                 origin.file = origin_filename;
                 if !infos.ignore_origin_duplicate {
                     let existing = store.get_media_by_origin(origin.clone()).await;
@@ -771,19 +809,19 @@ impl ModelController {
 
             let mut loaded_thumb = false;
             if let Some(thumbUrl) = thumbnail {
-                let headers = files.headers_as_tuple();
+                // Get headers, cookies, and referer from first request
                 let request = RsRequest {
                     upload_id: None,
                     url: thumbUrl,
                     mime: None,
                     size: None,
                     filename: None,
                     status: RsRequestStatus::Unprocessed,
-                    headers: headers.clone(),
-                    cookies: files.cookies.as_ref().and_then(|c| c.iter().map(|s| RsCookie::from_str(s).ok()).collect()),
+                    headers: first_request.and_then(|r| r.headers.clone()),
+                    cookies: first_request.and_then(|r| r.cookies.clone()),
                     files: None,
                     selected_file: None,
-                    referer: files.referer.clone(),
+                    referer: first_request.and_then(|r| r.referer.clone()),
                     ..Default::default()
                 };
 
@@ -819,10 +857,8 @@ impl ModelController {
 
             Ok(medias)
         } else {
-            let requests: Vec<RsRequest> = files.into(); 
-        
-            //let infos = infos.unwrap_or_else(|| MediaForUpdate::default());
-            for mut request in requests {
+            // Non-grouped path - process each request individually
+            for mut request in files.requests {
                 let upload_id = request.upload_id.clone().unwrap_or_else(|| nanoid!());
 
                 self.plugin_manager.fill_infos(&mut request).await;

src/model/medias.rs

@@ -4,7 +4,7 @@ use super::{mw_range::RangeDefinition, ImageRequestOptions, ImageUploadOptions};
 use crate::{
     domain::{
         media::{
-            self, GroupMediaDownload, MediaDownloadUrl, MediaForUpdate, MediaItemReference,
+            self, MediaForUpdate, MediaItemReference,
             MediaWithAction, MediasMessage,
         },
         ElementAction,
@@ -35,7 +35,7 @@ use axum::{
 use axum_extra::extract::Query;
 use futures::TryStreamExt;
 use hyper::{header::ACCEPT_RANGES, StatusCode};
-use rs_plugin_common_interfaces::{request::RsRequest, video::VideoConvertRequest};
+use rs_plugin_common_interfaces::{request::{RsGroupDownload, RsRequest}, video::VideoConvertRequest};
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
 use tokio::io::{AsyncRead, AsyncReadExt};
@@ -559,7 +559,7 @@ async fn handler_download(
     State(mc): State<ModelController>,
     user: ConnectedUser,
     Query(query): Query<UploadOption>,
-    Json(download): Json<GroupMediaDownload<MediaDownloadUrl>>,
+    Json(download): Json<RsGroupDownload>,
 ) -> Result<Json<Value>> {
     if query.spawn {
         tokio::spawn(async move {