rustbasic-medialibrary 0.0.6

Highly optimized, extremely secure, and powerful media library management package with Local and Cloud S3 integrations for the RustBasic Framework.
Documentation
use std::fs;
use std::path::{Path, PathBuf};
use std::env;

fn main() {
    // Skip if compiling on docs.rs
    if env::var("DOCS_RS").is_ok() {
        return;
    }

    // Determine parent project root
    let project_root = match env::var("PWD") {
        Ok(pwd) => PathBuf::from(pwd),
        Err(_) => match env::current_dir() {
            Ok(dir) => dir,
            Err(_) => return,
        },
    };

    // Ensure it's a Cargo project
    if !project_root.join("Cargo.toml").exists() {
        return;
    }

    // Skip if building the library itself
    if project_root.join("src/engine.rs").exists() && project_root.join("src/lib.rs").exists() {
        return;
    }

    // Check if we need to do scaffolding
    let helpers_dir = project_root.join("src/app/helpers");
    let helper_path = helpers_dir.join("media.rs");
    let mod_app_path = project_root.join("src/app/mod.rs");
    let mod_helpers_path = helpers_dir.join("mod.rs");

    let needs_media_helper = !helper_path.exists();
    
    let needs_app_mod = if mod_app_path.exists() {
        let content = fs::read_to_string(&mod_app_path).unwrap_or_default();
        !content.contains("pub mod helpers;")
    } else {
        false
    };

    let needs_helpers_mod = if mod_helpers_path.exists() {
        let content = fs::read_to_string(&mod_helpers_path).unwrap_or_default();
        !content.contains("pub mod media;")
    } else {
        false
    };

    if needs_media_helper || needs_app_mod || needs_helpers_mod {
        fs::create_dir_all(&helpers_dir).ok();
        inject_media_helper(&helpers_dir);
        update_app_mod_rs(&project_root);
        update_helpers_mod_rs(&helpers_dir);
    }
}

fn inject_media_helper(helpers_dir: &Path) {
    let helper_path = helpers_dir.join("media.rs");
    if helper_path.exists() {
        return;
    }

    let helper_template = r#"/* ---------------------------------------------------------
 * 🖼️ LABEL: MEDIA LIBRARY HELPERS (app/helpers/media.rs)
 * Pengolahan upload berkas, validasi MIME, kompresi WebP, dan thumbnail.
 * --------------------------------------------------------- */

use std::sync::Arc;
use rustbasic_medialibrary::{MediaLibrary, LocalStorageBackend, MediaFile};

/// Menginisialisasi instansi MediaLibrary lokal bawaan khusus gambar & PDF
pub fn initialize_media_library(upload_dir: &str) -> MediaLibrary {
    // 1. Buat local storage backend (menyimpan aset ke folder publik)
    let backend = Arc::new(LocalStorageBackend::new(upload_dir));

    // 2. Buat manager dengan batas maksimal 10MB dan pembatasan MIME type
    MediaLibrary::new(backend)
        .max_size(10 * 1024 * 1024) // Maksimal 10MB
        .allow_mime("image/jpeg")
        .allow_mime("image/png")
        .allow_mime("image/webp")
        .allow_mime("application/pdf")
}

/// Menginisialisasi instansi MediaLibrary lokal generik untuk SEMUA jenis berkas (ZIP, PDF, MP4, Excel, dll)
pub fn initialize_generic_media_library(upload_dir: &str) -> MediaLibrary {
    let backend = Arc::new(LocalStorageBackend::new(upload_dir));
    
    // Tanpa mendaftarkan allow_mime, MediaLibrary mengizinkan SEMUA format berkas secara default!
    MediaLibrary::new(backend)
        .max_size(100 * 1024 * 1024) // Batas 100MB untuk semua jenis berkas generik
}

/// Menangani unggahan avatar pengguna: validasi, ubah ke WebP, dan crop kotak 150x150!
pub fn handle_user_avatar_upload(
    raw_bytes: &[u8],
    original_name: &str,
    mime_type: &str
) -> Result<MediaFile, String> {
    // 1. Inisialisasi media library pada folder public/uploads/avatars
    let library = initialize_media_library("public/uploads/avatars");

    // 2. Upload file asli (akan divalidasi MIME type dan ukuran filenya)
    let original_file = library.upload(original_name, mime_type, raw_bytes)?;

    println!("🖼️ [Media Library] Berkas avatar berhasil diunggah: {}", original_file.filename);

    // 3. Konversi format berkas gambar ke WebP modern agar sangat hemat bandwidth!
    let webp_file = library.convert_to_webp(&original_file)?;
    println!("⚡ [Media Library] Transcoded ke WebP: {} -> {}", original_file.filename, webp_file.filename);

    // 4. Potong (crop) dan ubah ukuran (resize) menjadi avatar kotak presisi 150x150 piksel
    let avatar_thumbnail = library.create_thumbnail(&webp_file, 150, 150)?;
    println!("✅ [Media Library] Avatar thumbnail siap pakai: {}", avatar_thumbnail.filename);

    // Hapus file asli dan file Webp mentah agar ruang penyimpanan lokal efisien dan bersih!
    let _ = library.delete(&original_file);
    if webp_file.filename != avatar_thumbnail.filename {
        let _ = library.delete(&webp_file);
    }

    Ok(avatar_thumbnail)
}

/// Menangani unggahan berkas APAPUN (PDF, ZIP, CSV, MP4, docx, xlsx, dll) ke subfolder tujuan
pub fn handle_generic_file_upload(
    raw_bytes: &[u8],
    original_name: &str,
    mime_type: &str,
    target_subfolder: &str
) -> Result<MediaFile, String> {
    // 1. Inisialisasi library di folder public/uploads/<target_subfolder>
    let destination = format!("public/uploads/{}", target_subfolder.trim_matches('/'));
    let library = initialize_generic_media_library(&destination);

    // 2. Unggah berkas secara generik (nama berkas SHA-256 unik)
    let uploaded_file = library.upload(original_name, mime_type, raw_bytes)?;
    
    println!("📁 [Media Library] Berkas non-gambar berhasil diunggah: {} -> {}", uploaded_file.original_name, uploaded_file.url);
    Ok(uploaded_file)
}
"#;

    fs::write(helper_path, helper_template).ok();
}

fn update_app_mod_rs(project_root: &Path) {
    let mod_path = project_root.join("src/app/mod.rs");
    if !mod_path.exists() {
        return;
    }

    let content = fs::read_to_string(&mod_path).unwrap_or_default();
    if !content.contains("pub mod helpers;") {
        let mut new_content = content;
        new_content.push_str("\npub mod helpers;\n");
        fs::write(mod_path, new_content).ok();
    }
}

fn update_helpers_mod_rs(helpers_dir: &Path) {
    let mod_path = helpers_dir.join("mod.rs");
    let content = fs::read_to_string(&mod_path).unwrap_or_default();
    if !content.contains("pub mod media;") {
        let mut new_content = content;
        new_content.push_str("\npub mod media;\n");
        fs::write(mod_path, new_content).ok();
    }
}