Changing

migrations/20250420185217_init_migration.sql

@@ -6,10 +6,17 @@ CREATE TABLE IF NOT EXISTS "songQueue" (
     id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
     filename TEXT NOT NULL,
     status TEXT CHECK (status IN ('pending', 'ready', 'processing', 'done')),
-    data BYTEA NULL,
     user_id UUID NULL
 );
 
+CREATE TABLE IF NOT EXISTS "songQueueData" (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    file_key TEXT NOT NULL,
+    bucket TEXT NOT NULL,
+    region TEXT NOT NULL,
+    song_queue_id UUID NOT NULL
+);
+
 -- Table to store queued metadata
 CREATE TABLE IF NOT EXISTS "metadataQueue" (
     id UUID PRIMARY KEY DEFAULT gen_random_uuid(),

src/callers/queue/song.rs

@@ -162,7 +162,6 @@ pub mod endpoint {
                             if valid {
                                 match repo::song::insert(
                                     &pool,
-                                    &raw_data,
                                     &file_name,
                                     &crate::repo::queue::song::status::PENDING.to_string(),
                                 )
@@ -172,69 +171,43 @@ pub mod endpoint {
                                         results.push(queued_song);
                                         println!("Uploading to bucket");
 
-                                        let s3_endpoint_url =
+                                        let lab_config = crate::util::maze::get_config();
-                                            sienvy::environment::get_env("S3_ENDPOINT_URL");
-                                        let bucket_name =
-                                            sienvy::environment::get_env("S3_BUCKET_NAME");
-                                        let region =
-                                            sienvy::environment::get_env("GARAGE_S3_REGION");
-                                        let access_key_id = sienvy::environment::get_env(
-                                            "GARAGE_DEFAULT_ACCESS_KEY",
-                                        );
-                                        let secret_key = sienvy::environment::get_env(
-                                            "GARAGE_DEFAULT_SECRET_KEY",
-                                        );
-
-                                        let lab_config = labyrinth::config::Config {
-                                            url: s3_endpoint_url.value,
-                                            bucket: bucket_name.value,
-                                            region: region.value,
-                                            access_key_id: access_key_id.value,
-                                            secret_key: secret_key.value,
-                                        };
-
-                                        println!("Labyrinth config: {lab_config:?}");
 
                                         let lr = labyrinth::Labyrinth { config: lab_config };
                                         let data = labyrinth::Data {
                                             raw_data: copied_raw_data,
                                             ..Default::default()
                                         };
+                                        /*
                                         let filename = simodels::song::generate_filename(
                                             simodels::types::MusicType::FlacExtension,
                                             true,
                                         )
                                         .unwrap();
-                                        println!("Filename: {filename:?}");
+                                        */
-                                        let file_path = format!("queued/song/{filename}");
+                                        println!("Filename: {file_name:?}");
+                                        let file_path = format!("queued/song/{file_name}");
                                         println!("Path: {file_path:?}");
 
                                         match lr.upload(&file_path, &data).await {
                                             Ok(res) => {
                                                 println!("Result: {res:?}");
 
-                                                println!("Downloading file");
+                                                println!("Saving to db");
-                                                match lr.download(&file_path).await {
-                                                    Ok(res) => {
-                                                        if res.is_empty() {
-                                                            println!("This should not be empty");
-                                                        } else {
-                                                            println!("Size: {:?}", res.len());
-                                                            println!("Going to delete file");
 
-                                                            match lr.delete(&file_path).await {
+                                                match repo::data::insert(
-                                                                Ok(res) => {
+                                                    &pool,
-                                                                    println!("Result: {res:?}");
+                                                    &file_path,
-                                                                    println!("Deleted");
+                                                    &lr.config.bucket,
-                                                                }
+                                                    &lr.config.region,
-                                                                Err(err) => {
+                                                    &queued_song,
-                                                                    eprintln!("Error: {err:?}");
+                                                )
-                                                                }
+                                                .await
-                                                            }
+                                                {
-                                                        }
+                                                    Ok(_id) => {}
-                                                    }
                                                     Err(err) => {
                                                         eprintln!("Error: {err:?}");
+                                                        return (axum::http::StatusCode::INTERNAL_SERVER_ERROR, axum::Json(response));
                                                     }
                                                 }
                                             }

src/lib.rs

@@ -0,0 +1,6 @@
+pub mod auth;
+pub mod callers;
+pub mod config;
+pub mod db;
+pub mod repo;
+pub mod util;

src/main.rs

@@ -1,18 +1,12 @@
-pub mod auth;
-pub mod callers;
-pub mod config;
-pub mod db;
-pub mod repo;
-
 #[tokio::main]
 async fn main() {
     // initialize tracing
     tracing_subscriber::fmt::init();
 
-    match tokio::net::TcpListener::bind(config::host::get_full()).await {
+    match tokio::net::TcpListener::bind(soaricarus_api::config::host::get_full()).await {
         Ok(listener) => {
             // build our application with routes
-            let app = config::init::app().await;
+            let app = soaricarus_api::config::init::app().await;
             axum::serve(listener, app).await.unwrap();
         }
         Err(err) => {
@@ -27,7 +21,7 @@ mod tests {
 
     use tower::ServiceExt;
 
-    use crate::db;
+    use soaricarus_api::db;
 
     mod db_mgr {
         use std::str::FromStr;
@@ -111,7 +105,7 @@ mod tests {
         use std::time::Duration;
 
         pub async fn app(pool: sqlx::PgPool) -> axum::Router {
-            crate::config::init::routes()
+            soaricarus_api::config::init::routes()
                 .await
                 .layer(axum::Extension(pool))
                 .layer(axum::extract::DefaultBodyLimit::max(1024 * 1024 * 1024))
@@ -197,7 +191,7 @@ mod tests {
                     "flac".to_string(),
                     "tests/I/track01.flac".to_string(),
                 ))),
-                crate::callers::queue::endpoints::QUEUESONG,
+                soaricarus_api::callers::queue::endpoints::QUEUESONG,
                 axum::http::Method::POST,
                 true,
             )
@@ -221,7 +215,7 @@ mod tests {
 
             match run_post(
                 Some(ReqBody::Json(payload)),
-                crate::callers::queue::endpoints::QUEUESONGLINKUSERID,
+                soaricarus_api::callers::queue::endpoints::QUEUESONGLINKUSERID,
                 axum::http::Method::PATCH,
                 true,
             )
@@ -240,7 +234,7 @@ mod tests {
         ) -> Result<axum::response::Response, axum::http::Error> {
             match run_post(
                 None,
-                crate::callers::queue::endpoints::NEXTQUEUESONG,
+                soaricarus_api::callers::queue::endpoints::NEXTQUEUESONG,
                 axum::http::Method::GET,
                 false,
             )
@@ -260,7 +254,7 @@ mod tests {
         ) -> Result<axum::response::Response, axum::http::Error> {
             let uri = format!(
                 "{}?id={}",
-                crate::callers::queue::endpoints::QUEUEMETADATA,
+                soaricarus_api::callers::queue::endpoints::QUEUEMETADATA,
                 id
             );
 
@@ -277,7 +271,7 @@ mod tests {
             app: &axum::Router,
             id: &uuid::Uuid,
         ) -> Result<axum::response::Response, axum::http::Error> {
-            let raw_uri = String::from(crate::callers::queue::endpoints::QUEUESONGDATA);
+            let raw_uri = String::from(soaricarus_api::callers::queue::endpoints::QUEUESONGDATA);
             let end_index = raw_uri.len() - 4;
             let mut uri: String = (&raw_uri[..end_index]).to_string();
             uri += &id.to_string();
@@ -299,7 +293,7 @@ mod tests {
                     simeta::detection::coverart::constants::JPEG_TYPE.to_string(),
                     "tests/I/Coverart-1.jpg".to_string(),
                 ))),
-                crate::callers::queue::endpoints::QUEUECOVERART,
+                soaricarus_api::callers::queue::endpoints::QUEUECOVERART,
                 axum::http::Method::POST,
                 true,
             )
@@ -321,7 +315,7 @@ mod tests {
 
             match run_post(
                 Some(ReqBody::Json(payload)),
-                crate::callers::queue::endpoints::QUEUEMETADATA,
+                soaricarus_api::callers::queue::endpoints::QUEUEMETADATA,
                 axum::http::Method::POST,
                 true,
             )
@@ -348,7 +342,7 @@ mod tests {
 
             match run_post(
                 Some(ReqBody::Json(payload)),
-                crate::callers::queue::endpoints::QUEUECOVERARTLINK,
+                soaricarus_api::callers::queue::endpoints::QUEUECOVERARTLINK,
                 axum::http::Method::PATCH,
                 true,
             )
@@ -371,7 +365,7 @@ mod tests {
 
             match run_post(
                 Some(ReqBody::Json(payload)),
-                crate::callers::endpoints::CREATECOVERART,
+                soaricarus_api::callers::endpoints::CREATECOVERART,
                 axum::http::Method::POST,
                 true,
             )
@@ -394,7 +388,7 @@ mod tests {
 
             match run_post(
                 Some(ReqBody::Json(payload)),
-                crate::callers::endpoints::CREATESONG,
+                soaricarus_api::callers::endpoints::CREATESONG,
                 axum::http::Method::POST,
                 true,
             )
@@ -417,7 +411,7 @@ mod tests {
 
             match run_post(
                 Some(ReqBody::Json(payload)),
-                crate::callers::queue::endpoints::QUEUESONG,
+                soaricarus_api::callers::queue::endpoints::QUEUESONG,
                 axum::http::Method::PATCH,
                 true,
             )
@@ -437,7 +431,7 @@ mod tests {
         ) -> Result<axum::response::Response, axum::http::Error> {
             let uri = format!(
                 "{}?id={}",
-                crate::callers::queue::endpoints::QUEUECOVERART,
+                soaricarus_api::callers::queue::endpoints::QUEUECOVERART,
                 coverart_queue_id
             );
 
@@ -513,7 +507,7 @@ mod tests {
             match super::request::song_queue_req(&app).await {
                 Ok(response) => {
                     let resp = super::util::get_resp_data::<
-                        crate::callers::queue::song::response::song_queue::Response,
+                        soaricarus_api::callers::queue::song::response::song_queue::Response,
                     >(response)
                     .await;
                     assert_eq!(false, resp.data.is_empty(), "Should not be empty");
@@ -527,7 +521,7 @@ mod tests {
                     {
                         Ok(response) => {
                             let resp = super::util::get_resp_data::<
-                                crate::callers::queue::song::response::link_user_id::Response,
+                                soaricarus_api::callers::queue::song::response::link_user_id::Response,
                             >(response)
                             .await;
                             assert_eq!(
@@ -539,7 +533,7 @@ mod tests {
                             match super::request::queue_metadata_req(&app, &song_queue_id).await {
                                 Ok(response) => {
                                     let resp = super::util::get_resp_data::<
-                                        crate::callers::queue::song::response::song_queue::Response,
+                                        soaricarus_api::callers::queue::song::response::song_queue::Response,
                                     >(response)
                                     .await;
                                     assert_eq!(false, resp.data.is_empty(), "Should not be empty");
@@ -570,7 +564,7 @@ mod tests {
             match super::request::upload_coverart_queue_req(&app).await {
                 Ok(response) => {
                     let resp = super::util::get_resp_data::<
-                        crate::callers::queue::coverart::response::queue::Response,
+                        soaricarus_api::callers::queue::coverart::response::queue::Response,
                     >(response)
                     .await;
                     assert_eq!(false, resp.data.is_empty(), "Should not be empty");
@@ -586,7 +580,7 @@ mod tests {
                     {
                         Ok(response) => {
                             let resp = super::util::get_resp_data::<
-                                crate::callers::queue::coverart::response::link::Response,
+                                soaricarus_api::callers::queue::coverart::response::link::Response,
                             >(response)
                             .await;
                             assert_eq!(false, resp.data.is_empty(), "Should not be empty");
@@ -616,7 +610,7 @@ mod tests {
             match queue_song_flow(&app).await {
                 Ok((song_response, user_id)) => {
                     let resp = super::util::get_resp_data::<
-                        crate::callers::queue::metadata::response::fetch_metadata::Response,
+                        soaricarus_api::callers::queue::metadata::response::fetch_metadata::Response,
                     >(song_response)
                     .await;
                     assert_eq!(false, resp.data.is_empty(), "Data should not be empty");
@@ -625,7 +619,7 @@ mod tests {
                     match super::request::create_song_req(&app, &song_queue_id, &user_id).await {
                         Ok(response) => {
                             let resp = super::util::get_resp_data::<
-                                crate::callers::song::response::create_metadata::Response,
+                                soaricarus_api::callers::song::response::create_metadata::Response,
                             >(response)
                             .await;
                             assert_eq!(
@@ -743,7 +737,7 @@ mod tests {
         ) -> serde_json::Value {
             serde_json::json!({
                 "id": song_queue_id,
-                "status": crate::repo::queue::song::status::READY
+                "status": soaricarus_api::repo::queue::song::status::READY
             })
         }
     }
@@ -771,7 +765,7 @@ mod tests {
         match request::song_queue_req(&app).await {
             Ok(response) => {
                 let resp = util::get_resp_data::<
-                    crate::callers::queue::song::response::song_queue::Response,
+                    soaricarus_api::callers::queue::song::response::song_queue::Response,
                 >(response)
                 .await;
                 assert_eq!(false, resp.data.is_empty(), "Should not be empty");
@@ -807,7 +801,7 @@ mod tests {
         match request::song_queue_req(&app).await {
             Ok(response) => {
                 let resp = util::get_resp_data::<
-                    crate::callers::queue::song::response::song_queue::Response,
+                    soaricarus_api::callers::queue::song::response::song_queue::Response,
                 >(response)
                 .await;
                 assert_eq!(false, resp.data.is_empty(), "Should not be empty");
@@ -820,7 +814,7 @@ mod tests {
                 match request::song_queue_link_req(&app, &song_queue_id, &user_id).await {
                     Ok(response) => {
                         let resp = util::get_resp_data::<
-                            crate::callers::queue::song::response::link_user_id::Response,
+                            soaricarus_api::callers::queue::song::response::link_user_id::Response,
                         >(response)
                         .await;
                         let collected_user_id = &resp.data[0];
@@ -872,20 +866,20 @@ mod tests {
         match sequence_flow::queue_song_and_coverart_flow(&app).await {
             Ok((resp_one, song_queue_id)) => {
                 let resp = util::get_resp_data::<
-                    crate::callers::queue::coverart::response::fetch_coverart_no_data::Response,
+                    soaricarus_api::callers::queue::coverart::response::fetch_coverart_no_data::Response,
                 >(resp_one)
                 .await;
                 assert_eq!(false, resp.data.is_empty(), "Should not be empty");
 
                 let _resp_coverart_queue_id = resp.data[0].id;
 
-                let old = crate::repo::queue::song::status::PENDING;
+                let old = soaricarus_api::repo::queue::song::status::PENDING;
-                let target_status = crate::repo::queue::song::status::READY;
+                let target_status = soaricarus_api::repo::queue::song::status::READY;
 
                 match request::update_song_queue_status_req(&app, &song_queue_id).await {
                     Ok(response) => {
                         let resp = util::get_resp_data::<
-                            crate::callers::queue::song::response::update_status::Response,
+                            soaricarus_api::callers::queue::song::response::update_status::Response,
                         >(response)
                         .await;
                         assert_eq!(false, resp.data.is_empty(), "Should not be empty");
@@ -900,7 +894,7 @@ mod tests {
                         match request::fetch_queue_req(&app).await {
                             Ok(response) => {
                                 let resp = util::get_resp_data::<
-                                    crate::callers::queue::song::response::fetch_queue_song::Response,
+                                    soaricarus_api::callers::queue::song::response::fetch_queue_song::Response,
                                 >(response)
                                 .await;
                                 assert_eq!(false, resp.data.is_empty(), "Should not be empty");
@@ -946,7 +940,7 @@ mod tests {
         match request::song_queue_req(&app).await {
             Ok(response) => {
                 let resp = util::get_resp_data::<
-                    crate::callers::queue::song::response::song_queue::Response,
+                    soaricarus_api::callers::queue::song::response::song_queue::Response,
                 >(response)
                 .await;
                 assert_eq!(false, resp.data.is_empty(), "Should not be empty");
@@ -981,7 +975,7 @@ mod tests {
                             let songpath = song.song_path().unwrap();
 
                             let raw_uri =
-                                String::from(crate::callers::queue::endpoints::QUEUESONGUPDATE);
+                                String::from(soaricarus_api::callers::queue::endpoints::QUEUESONGUPDATE);
                             let end_index = raw_uri.len() - 5;
 
                             let uri = format!(
@@ -1009,7 +1003,7 @@ mod tests {
                             {
                                 Ok(response) => {
                                     let resp = util::get_resp_data::<
-                                        crate::callers::queue::song::response::update_song_queue::Response,
+                                        soaricarus_api::callers::queue::song::response::update_song_queue::Response,
                                     >(response)
                                     .await;
                                     assert_eq!(false, resp.data.is_empty(), "Should not be empty");
@@ -1066,7 +1060,7 @@ mod tests {
         match request::song_queue_req(&app).await {
             Ok(response) => {
                 let resp = util::get_resp_data::<
-                    crate::callers::queue::song::response::song_queue::Response,
+                    soaricarus_api::callers::queue::song::response::song_queue::Response,
                 >(response)
                 .await;
                 assert_eq!(false, resp.data.is_empty(), "Should not be empty");
@@ -1117,20 +1111,20 @@ mod tests {
         match sequence_flow::queue_song_and_coverart_flow(&app).await {
             Ok((resp_one, song_queue_id)) => {
                 let resp = util::get_resp_data::<
-                    crate::callers::queue::coverart::response::fetch_coverart_no_data::Response,
+                    soaricarus_api::callers::queue::coverart::response::fetch_coverart_no_data::Response,
                 >(resp_one)
                 .await;
                 assert_eq!(false, resp.data.is_empty(), "Should not be empty");
 
                 let _resp_coverart_queue_id = resp.data[0].id;
 
-                let old = crate::repo::queue::song::status::PENDING;
+                let old = soaricarus_api::repo::queue::song::status::PENDING;
-                let done = crate::repo::queue::song::status::READY;
+                let done = soaricarus_api::repo::queue::song::status::READY;
 
                 match request::update_song_queue_status_req(&app, &song_queue_id).await {
                     Ok(response) => {
                         let resp = util::get_resp_data::<
-                            crate::callers::queue::song::response::update_status::Response,
+                            soaricarus_api::callers::queue::song::response::update_status::Response,
                         >(response)
                         .await;
                         assert_eq!(false, resp.data.is_empty(), "Should not be empty");
@@ -1175,7 +1169,7 @@ mod tests {
         match request::song_queue_req(&app).await {
             Ok(response) => {
                 let resp = util::get_resp_data::<
-                    crate::callers::queue::song::response::song_queue::Response,
+                    soaricarus_api::callers::queue::song::response::song_queue::Response,
                 >(response)
                 .await;
                 assert_eq!(false, resp.data.is_empty(), "Should not be empty");
@@ -1184,7 +1178,7 @@ mod tests {
                 match request::queue_metadata_req(&app, &resp.data[0]).await {
                     Ok(response) => {
                         let resp = util::get_resp_data::<
-                            crate::callers::queue::song::response::song_queue::Response,
+                            soaricarus_api::callers::queue::song::response::song_queue::Response,
                         >(response)
                         .await;
                         assert_eq!(false, resp.data.is_empty(), "Should not be empty");
@@ -1225,7 +1219,7 @@ mod tests {
         match sequence_flow::queue_song_flow(&app).await {
             Ok((response, _user_id)) => {
                 let resp = util::get_resp_data::<
-                    crate::callers::queue::metadata::response::fetch_metadata::Response,
+                    soaricarus_api::callers::queue::metadata::response::fetch_metadata::Response,
                 >(response)
                 .await;
                 assert_eq!(false, resp.data.is_empty(), "Data should not be empty");
@@ -1261,7 +1255,7 @@ mod tests {
         match request::upload_coverart_queue_req(&app).await {
             Ok(response) => {
                 let resp = util::get_resp_data::<
-                    crate::callers::queue::coverart::response::queue::Response,
+                    soaricarus_api::callers::queue::coverart::response::queue::Response,
                 >(response)
                 .await;
                 assert_eq!(false, resp.data.is_empty(), "Should not be empty");
@@ -1298,7 +1292,7 @@ mod tests {
         match request::song_queue_req(&app).await {
             Ok(response) => {
                 let resp = util::get_resp_data::<
-                    crate::callers::queue::coverart::response::queue::Response,
+                    soaricarus_api::callers::queue::coverart::response::queue::Response,
                 >(response)
                 .await;
                 assert_eq!(false, resp.data.is_empty(), "Should not be empty");
@@ -1309,7 +1303,7 @@ mod tests {
                 match request::upload_coverart_queue_req(&app).await {
                     Ok(response) => {
                         let resp = util::get_resp_data::<
-                            crate::callers::queue::coverart::response::queue::Response,
+                            soaricarus_api::callers::queue::coverart::response::queue::Response,
                         >(response)
                         .await;
                         assert_eq!(false, resp.data.is_empty(), "Should not be empty");
@@ -1325,7 +1319,7 @@ mod tests {
                         {
                             Ok(response) => {
                                 let resp = util::get_resp_data::<
-                                    crate::callers::queue::coverart::response::link::Response,
+                                    soaricarus_api::callers::queue::coverart::response::link::Response,
                                 >(response)
                                 .await;
                                 assert_eq!(false, resp.data.is_empty(), "Should not be empty");
@@ -1379,7 +1373,7 @@ mod tests {
         match request::song_queue_req(&app).await {
             Ok(response) => {
                 let resp = util::get_resp_data::<
-                    crate::callers::queue::coverart::response::queue::Response,
+                    soaricarus_api::callers::queue::coverart::response::queue::Response,
                 >(response)
                 .await;
                 assert_eq!(false, resp.data.is_empty(), "Should not be empty");
@@ -1389,7 +1383,7 @@ mod tests {
                 match sequence_flow::queue_coverart_flow(&app, &song_queue_id).await {
                     Ok(response) => {
                         let resp = util::get_resp_data::<
-                            crate::callers::queue::coverart::response::fetch_coverart_no_data::Response,
+                            soaricarus_api::callers::queue::coverart::response::fetch_coverart_no_data::Response,
                         >(response)
                         .await;
                         assert_eq!(false, resp.data.is_empty(), "Should not be empty");
@@ -1429,7 +1423,7 @@ mod tests {
         match request::song_queue_req(&app).await {
             Ok(response) => {
                 let resp = util::get_resp_data::<
-                    crate::callers::queue::coverart::response::queue::Response,
+                    soaricarus_api::callers::queue::coverart::response::queue::Response,
                 >(response)
                 .await;
                 assert_eq!(false, resp.data.is_empty(), "Should not be empty");
@@ -1440,7 +1434,7 @@ mod tests {
                 match request::upload_coverart_queue_req(&app).await {
                     Ok(response) => {
                         let resp = util::get_resp_data::<
-                            crate::callers::queue::coverart::response::queue::Response,
+                            soaricarus_api::callers::queue::coverart::response::queue::Response,
                         >(response)
                         .await;
                         assert_eq!(false, resp.data.is_empty(), "Should not be empty");
@@ -1456,7 +1450,7 @@ mod tests {
                         {
                             Ok(response) => {
                                 let resp = util::get_resp_data::<
-                                    crate::callers::queue::coverart::response::link::Response,
+                                    soaricarus_api::callers::queue::coverart::response::link::Response,
                                 >(response)
                                 .await;
                                 assert_eq!(false, resp.data.is_empty(), "Should not be empty");
@@ -1471,7 +1465,7 @@ mod tests {
                                 );
 
                                 let raw_uri = String::from(
-                                    crate::callers::queue::endpoints::QUEUECOVERARTDATA,
+                                    soaricarus_api::callers::queue::endpoints::QUEUECOVERARTDATA,
                                 );
                                 let end_index = raw_uri.len() - 5;
                                 let uri = format!(
@@ -1562,7 +1556,7 @@ mod tests {
         match sequence_flow::queue_song_flow(&app).await {
             Ok((response, user_id)) => {
                 let resp = util::get_resp_data::<
-                    crate::callers::queue::metadata::response::fetch_metadata::Response,
+                    soaricarus_api::callers::queue::metadata::response::fetch_metadata::Response,
                 >(response)
                 .await;
                 assert_eq!(false, resp.data.is_empty(), "Data should not be empty");
@@ -1571,7 +1565,7 @@ mod tests {
                 match request::create_song_req(&app, &song_q_id, &user_id).await {
                     Ok(response) => {
                         let resp = util::get_resp_data::<
-                            crate::callers::song::response::create_metadata::Response,
+                            soaricarus_api::callers::song::response::create_metadata::Response,
                         >(response)
                         .await;
                         assert_eq!(
@@ -1625,7 +1619,7 @@ mod tests {
         match sequence_flow::queue_song_flow(&app).await {
             Ok((response, user_id)) => {
                 let resp = util::get_resp_data::<
-                    crate::callers::queue::metadata::response::fetch_metadata::Response,
+                    soaricarus_api::callers::queue::metadata::response::fetch_metadata::Response,
                 >(response)
                 .await;
                 assert_eq!(false, resp.data.is_empty(), "Data should not be empty");
@@ -1634,7 +1628,7 @@ mod tests {
                 match request::create_song_req(&app, &song_queue_id, &user_id).await {
                     Ok(response) => {
                         let resp = util::get_resp_data::<
-                            crate::callers::song::response::create_metadata::Response,
+                            soaricarus_api::callers::song::response::create_metadata::Response,
                         >(response)
                         .await;
                         assert_eq!(
@@ -1655,7 +1649,7 @@ mod tests {
                         match sequence_flow::queue_coverart_flow(&app, &song_queue_id).await {
                             Ok(response) => {
                                 let resp = util::get_resp_data::<
-                                                    crate::callers::queue::coverart::response::fetch_coverart_no_data::Response,
+                                                    soaricarus_api::callers::queue::coverart::response::fetch_coverart_no_data::Response,
                                                 >(response)
                                                 .await;
                                 assert_eq!(false, resp.data.is_empty(), "Should not be empty");
@@ -1670,7 +1664,7 @@ mod tests {
                                 {
                                     Ok(response) => {
                                         let resp = util::get_resp_data::<
-                                                            crate::callers::coverart::response::create_coverart::Response,
+                                                            soaricarus_api::callers::coverart::response::create_coverart::Response,
                                                         >(response)
                                                         .await;
                                         assert_eq!(
@@ -1725,7 +1719,7 @@ mod tests {
         match sequence_flow::queue_song_flow(&app).await {
             Ok((response, user_id)) => {
                 let resp = util::get_resp_data::<
-                    crate::callers::queue::metadata::response::fetch_metadata::Response,
+                    soaricarus_api::callers::queue::metadata::response::fetch_metadata::Response,
                 >(response)
                 .await;
                 assert_eq!(false, resp.data.is_empty(), "Data should not be empty");
@@ -1734,7 +1728,7 @@ mod tests {
                 match request::create_song_req(&app, &song_q_id, &user_id).await {
                     Ok(response) => {
                         let resp = util::get_resp_data::<
-                            crate::callers::song::response::create_metadata::Response,
+                            soaricarus_api::callers::song::response::create_metadata::Response,
                         >(response)
                         .await;
                         assert_eq!(
@@ -1761,7 +1755,7 @@ mod tests {
                             .oneshot(
                                 request::run_post(
                                     Some(request::ReqBody::Json(payload)),
-                                    crate::callers::queue::endpoints::QUEUESONGDATAWIPE,
+                                    soaricarus_api::callers::queue::endpoints::QUEUESONGDATAWIPE,
                                     axum::http::Method::PATCH,
                                     true,
                                 )
@@ -1771,7 +1765,7 @@ mod tests {
                             .await
                         {
                             Ok(response) => {
-                                let resp = util::get_resp_data::<crate::callers::queue::song::response::wipe_data_from_song_queue::Response>(response).await;
+                                let resp = util::get_resp_data::<soaricarus_api::callers::queue::song::response::wipe_data_from_song_queue::Response>(response).await;
                                 assert_eq!(
                                     false,
                                     resp.data.is_empty(),
@@ -1832,7 +1826,7 @@ mod tests {
         match sequence_flow::queue_song_flow(&app).await {
             Ok((response, user_id)) => {
                 let resp = util::get_resp_data::<
-                    crate::callers::queue::metadata::response::fetch_metadata::Response,
+                    soaricarus_api::callers::queue::metadata::response::fetch_metadata::Response,
                 >(response)
                 .await;
                 assert_eq!(false, resp.data.is_empty(), "Data should not be empty");
@@ -1841,7 +1835,7 @@ mod tests {
                 match request::create_song_req(&app, &song_queue_id, &user_id).await {
                     Ok(response) => {
                         let resp = util::get_resp_data::<
-                            crate::callers::song::response::create_metadata::Response,
+                            soaricarus_api::callers::song::response::create_metadata::Response,
                         >(response)
                         .await;
                         assert_eq!(
@@ -1864,7 +1858,7 @@ mod tests {
                         match sequence_flow::queue_coverart_flow(&app, &song_queue_id).await {
                             Ok(response) => {
                                 let resp = util::get_resp_data::<
-                                    crate::callers::queue::coverart::response::fetch_coverart_no_data::Response,
+                                    soaricarus_api::callers::queue::coverart::response::fetch_coverart_no_data::Response,
                                 >(response)
                                 .await;
                                 assert_eq!(false, resp.data.is_empty(), "Should not be empty");
@@ -1880,7 +1874,7 @@ mod tests {
                                     .oneshot(
                                         request::run_post(
                                             Some(request::ReqBody::Json(payload)),
-                                            crate::callers::queue::endpoints::QUEUECOVERARTDATAWIPE,
+                                            soaricarus_api::callers::queue::endpoints::QUEUECOVERARTDATAWIPE,
                                             axum::http::Method::PATCH,
                                             true,
                                         )
@@ -1891,7 +1885,7 @@ mod tests {
                                 {
                                     Ok(response) => {
                                         let resp = util::get_resp_data::<
-                                            crate::callers::queue::coverart::response::wipe_data_from_coverart_queue::Response,
+                                            soaricarus_api::callers::queue::coverart::response::wipe_data_from_coverart_queue::Response,
                                         >(response)
                                         .await;
                                         assert_eq!(
@@ -1948,7 +1942,7 @@ mod tests {
 
             let (id, _, _, _) = test_data::song_id().await.unwrap();
 
-            let uri = format!("{}?id={id}", crate::callers::endpoints::GETSONGS);
+            let uri = format!("{}?id={id}", soaricarus_api::callers::endpoints::GETSONGS);
 
             match app
                 .clone()
@@ -1961,7 +1955,7 @@ mod tests {
             {
                 Ok(response) => {
                     let resp = super::util::get_resp_data::<
-                        crate::callers::song::response::get_songs::Response,
+                        soaricarus_api::callers::song::response::get_songs::Response,
                     >(response)
                     .await;
                     assert_eq!(false, resp.data.is_empty(), "Should not be empty");
@@ -1998,7 +1992,7 @@ mod tests {
 
             let id = test_data::coverart_id().await.unwrap();
 
-            let uri = format!("{}?id={id}", crate::callers::endpoints::GETCOVERART);
+            let uri = format!("{}?id={id}", soaricarus_api::callers::endpoints::GETCOVERART);
 
             match app
                 .clone()
@@ -2011,7 +2005,7 @@ mod tests {
             {
                 Ok(response) => {
                     let resp = super::util::get_resp_data::<
-                        crate::callers::coverart::response::get_coverart::Response,
+                        soaricarus_api::callers::coverart::response::get_coverart::Response,
                     >(response)
                     .await;
                     assert_eq!(false, resp.data.is_empty(), "Should not be empty");
@@ -2078,7 +2072,7 @@ mod tests {
 
             let (id, _, _, _) = test_data::song_id().await.unwrap();
 
-            let my_url = crate::callers::endpoints::STREAMSONG;
+            let my_url = soaricarus_api::callers::endpoints::STREAMSONG;
             let last = my_url.len() - 5;
             let uri = format!("{}/{id}", &my_url[0..last]);
 
@@ -2133,7 +2127,7 @@ mod tests {
             let (id, _, _, _) = test_data::song_id().await.unwrap();
 
             let uri =
-                super::util::format_url_with_value(crate::callers::endpoints::DOWNLOADSONG, &id)
+                super::util::format_url_with_value(soaricarus_api::callers::endpoints::DOWNLOADSONG, &id)
                     .await;
 
             match app
@@ -2187,7 +2181,7 @@ mod tests {
             let id = test_data::coverart_id().await.unwrap();
 
             let uri = super::util::format_url_with_value(
-                crate::callers::endpoints::DOWNLOADCOVERART,
+                soaricarus_api::callers::endpoints::DOWNLOADCOVERART,
                 &id,
             )
             .await;
@@ -2310,7 +2304,7 @@ mod tests {
             .unwrap();
 
             let uri =
-                super::util::format_url_with_value(crate::callers::endpoints::DELETESONG, &id)
+                super::util::format_url_with_value(soaricarus_api::callers::endpoints::DELETESONG, &id)
                     .await;
 
             match app
@@ -2324,7 +2318,7 @@ mod tests {
             {
                 Ok(response) => {
                     let resp = super::util::get_resp_data::<
-                        crate::callers::song::response::delete_song::Response,
+                        soaricarus_api::callers::song::response::delete_song::Response,
                     >(response)
                     .await;
                     assert_eq!(false, resp.data.is_empty(), "Response has no data");
@@ -2384,7 +2378,7 @@ mod tests {
                 .oneshot(
                     super::request::run_post(
                         None,
-                        crate::callers::endpoints::GETALLSONGS,
+                        soaricarus_api::callers::endpoints::GETALLSONGS,
                         axum::http::Method::GET,
                         false,
                     )
@@ -2395,7 +2389,7 @@ mod tests {
             {
                 Ok(response) => {
                     let resp = super::util::get_resp_data::<
-                        crate::callers::song::response::get_songs::Response,
+                        soaricarus_api::callers::song::response::get_songs::Response,
                     >(response)
                     .await;
                     assert_eq!(false, resp.data.is_empty(), "Should not be empty");

src/repo/queue/data.rs

@@ -0,0 +1,78 @@
+use sqlx::Row;
+
+pub async fn insert(
+    pool: &sqlx::PgPool,
+    file_key: &str,
+    bucket: &str,
+    region: &str,
+    song_queue_id: &uuid::Uuid,
+) -> Result<uuid::Uuid, sqlx::Error> {
+    match sqlx::query(
+        r#"
+        INSERT INTO "songQueueData" (file_key, bucket, region, song_queue_id) VALUES($1, $2, $3, $4) RETURNING id;
+        "#,
+    )
+    .bind(file_key)
+    .bind(bucket)
+    .bind(region)
+    .bind(song_queue_id)
+    .fetch_one(pool).await {
+        Ok(row) => {
+            let id: uuid::Uuid = row.try_get("id")?;
+            Ok(id)
+        }
+        Err(_err) => Err(sqlx::Error::RowNotFound),
+    }
+}
+
+pub async fn get(
+    pool: &sqlx::PgPool,
+    id: &uuid::Uuid,
+) -> Result<(uuid::Uuid, String, String, String, uuid::Uuid), sqlx::Error> {
+    match sqlx::query(
+        r#"
+        SELECT id, file_key, bucket, region, song_queue_id FROM "songQueueData"
+        WHERE id = $1
+        "#,
+    )
+    .bind(id)
+    .fetch_one(pool)
+    .await
+    {
+        Ok(row) => {
+            let file_key: String = row.try_get("file_key")?;
+            let bucket: String = row.try_get("bucket")?;
+            let region: String = row.try_get("region")?;
+            let song_queue_id: uuid::Uuid = row.try_get("song_queue_id")?;
+
+            Ok((*id, file_key, bucket, region, song_queue_id))
+        }
+        Err(err) => Err(err),
+    }
+}
+
+pub async fn get_with_song_queue_id(
+    pool: &sqlx::PgPool,
+    song_queue_id: &uuid::Uuid,
+) -> Result<(uuid::Uuid, String, String, String, uuid::Uuid), sqlx::Error> {
+    match sqlx::query(
+        r#"
+        SELECT id, file_key, bucket, region, song_queue_id FROM "songQueueData"
+        WHERE song_queue_id = $1
+        "#,
+    )
+    .bind(song_queue_id)
+    .fetch_one(pool)
+    .await
+    {
+        Ok(row) => {
+            let id: uuid::Uuid = row.try_get("id")?;
+            let file_key: String = row.try_get("file_key")?;
+            let bucket: String = row.try_get("bucket")?;
+            let region: String = row.try_get("region")?;
+
+            Ok((id, file_key, bucket, region, *song_queue_id))
+        }
+        Err(err) => Err(err),
+    }
+}

src/repo/queue/mod.rs

@@ -1,3 +1,4 @@
 pub mod coverart;
+pub mod data;
 pub mod metadata;
 pub mod song;

src/repo/queue/song.rs

@@ -24,16 +24,14 @@ pub mod dbtype {
 
 pub async fn insert(
     pool: &sqlx::PgPool,
-    data: &Vec<u8>,
     filename: &String,
     status: &String,
 ) -> Result<uuid::Uuid, sqlx::Error> {
     let result = sqlx::query(
         r#"
-        INSERT INTO "songQueue" (data, filename, status) VALUES($1, $2, $3) RETURNING id;
+        INSERT INTO "songQueue" (filename, status) VALUES($1, $2, $3) RETURNING id;
         "#,
     )
-    .bind(data)
     .bind(filename)
     .bind(status)
     .fetch_one(pool)

src/util/mod.rs

@@ -0,0 +1,27 @@
+
+
+pub mod maze {
+    pub fn get_config() -> labyrinth::config::Config {
+
+                                        let s3_endpoint_url =
+                                            sienvy::environment::get_env("S3_ENDPOINT_URL");
+                                        let bucket_name =
+                                            sienvy::environment::get_env("S3_BUCKET_NAME");
+                                        let region =
+                                            sienvy::environment::get_env("GARAGE_S3_REGION");
+                                        let access_key_id = sienvy::environment::get_env(
+                                            "GARAGE_DEFAULT_ACCESS_KEY",
+                                        );
+                                        let secret_key = sienvy::environment::get_env(
+                                            "GARAGE_DEFAULT_SECRET_KEY",
+                                        );
+
+                                        labyrinth::config::Config {
+                                            url: s3_endpoint_url.value,
+                                            bucket: bucket_name.value,
+                                            region: region.value,
+                                            access_key_id: access_key_id.value,
+                                            secret_key: secret_key.value,
+                                        }
+    }
+}

test_migrations/20250725213944_init.sql

@@ -6,10 +6,17 @@ CREATE TABLE IF NOT EXISTS "songQueue" (
     id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
     filename TEXT NOT NULL,
     status TEXT CHECK (status IN ('pending', 'ready', 'processing', 'done')),
-    data BYTEA NULL,
     user_id UUID NULL
 );
 
+CREATE TABLE IF NOT EXISTS "songQueueData" (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    file_key TEXT NOT NULL,
+    bucket TEXT NOT NULL,
+    region TEXT NOT NULL,
+    song_queue_id UUID NOT NULL
+);
+
 -- Table to store queued metadata
 CREATE TABLE IF NOT EXISTS "metadataQueue" (
     id UUID PRIMARY KEY DEFAULT gen_random_uuid(),