mesa_dev/

helpers.rs

//! High-level helper functions for common operations.
//!
//! These helpers provide convenient methods that combine multiple SDK operations
//! into single calls.
//!
//! # Example
//!
//! ```rust,no_run
//! use mesa_dev::{Mesa, MesaError};
//! use mesa_dev::helpers::{LargeFile, UploadLargeFilesOptions};
//! use mesa_dev::models::Author;
//!
//! # async fn run() -> Result<(), MesaError> {
//! let client = Mesa::new("api-key");
//! let content = std::fs::read("large-model.bin").unwrap();
//!
//! let result = mesa_dev::helpers::upload_large_files(
//!     &client,
//!     UploadLargeFilesOptions {
//!         org: "my-org".into(),
//!         repo: "my-repo".into(),
//!         branch: "main".into(),
//!         message: "Add large model".into(),
//!         author: Author {
//!             name: "Bot".into(),
//!             email: "bot@example.com".into(),
//!             date: None,
//!         },
//!         files: vec![LargeFile {
//!             path: "models/model.bin".into(),
//!             content,
//!         }],
//!         base_sha: None,
//!     },
//! ).await?;
//!
//! println!("Created commit: {}", result.sha);
//! # Ok(())
//! # }
//! ```

use sha2::{Digest, Sha256};

use crate::MesaClient;
use crate::error::MesaError;
use crate::http_client::HttpClient;
use crate::models::{
    Author, CommitFileChange, CommitSummary, CreateCommitWithLfsRequest, LfsObjectSpec,
    UploadLfsObjectsRequest,
};

/// A large file to upload via LFS.
#[derive(Debug, Clone)]
pub struct LargeFile {
    /// Path in the repository (e.g., "models/large-model.bin").
    pub path: String,
    /// File content as bytes.
    pub content: Vec<u8>,
}

/// Options for uploading large files.
#[derive(Debug, Clone)]
pub struct UploadLargeFilesOptions {
    /// Organization slug.
    pub org: String,
    /// Repository name.
    pub repo: String,
    /// Target branch.
    pub branch: String,
    /// Commit message.
    pub message: String,
    /// Commit author.
    pub author: Author,
    /// Files to upload.
    pub files: Vec<LargeFile>,
    /// Optional base SHA for optimistic locking.
    pub base_sha: Option<String>,
}

/// Upload large files to a repository using LFS.
///
/// This convenience function:
/// 1. Computes SHA-256 of each file
/// 2. Requests pre-signed upload URLs from the LFS endpoint
/// 3. Uploads file content directly to S3
/// 4. Creates a commit with LFS pointer references
///
/// # Errors
///
/// Returns [`MesaError`] if any step fails (API request, S3 upload, or commit creation).
///
/// # Example
///
/// ```rust,no_run
/// use mesa_dev::{Mesa, MesaError};
/// use mesa_dev::helpers::{upload_large_files, LargeFile, UploadLargeFilesOptions};
/// use mesa_dev::models::Author;
///
/// # async fn run() -> Result<(), MesaError> {
/// let client = Mesa::new("api-key");
/// let content = std::fs::read("large-model.bin").unwrap();
///
/// let result = upload_large_files(
///     &client,
///     UploadLargeFilesOptions {
///         org: "my-org".into(),
///         repo: "my-repo".into(),
///         branch: "main".into(),
///         message: "Add large model".into(),
///         author: Author {
///             name: "Bot".into(),
///             email: "bot@example.com".into(),
///             date: None,
///         },
///         files: vec![LargeFile {
///             path: "models/model.bin".into(),
///             content,
///         }],
///         base_sha: None,
///     },
/// ).await?;
///
/// println!("Created commit: {}", result.sha);
/// # Ok(())
/// # }
/// ```
pub async fn upload_large_files<C: HttpClient>(
    client: &MesaClient<C>,
    options: UploadLargeFilesOptions,
) -> Result<CommitSummary, MesaError> {
    let UploadLargeFilesOptions {
        org,
        repo,
        branch,
        message,
        author,
        files,
        base_sha,
    } = options;

    // 1. Compute SHA-256 for each file
    let prepared: Vec<_> = files
        .iter()
        .map(|f| {
            let mut hasher = Sha256::new();
            hasher.update(&f.content);
            let hash = hasher.finalize();
            let oid = hex::encode(hash);
            let size = f.content.len() as u64;
            (f, oid, size)
        })
        .collect();

    // 2. Request upload URLs
    let upload_req = UploadLfsObjectsRequest {
        objects: prepared
            .iter()
            .map(|(_, oid, size)| LfsObjectSpec {
                oid: oid.clone(),
                size: *size,
            })
            .collect(),
    };
    let upload_resp = client.lfs(&org, &repo).upload(&upload_req).await?;

    // 3. Upload content for objects that need it
    for obj_status in &upload_resp.objects {
        if let Some(ref error) = obj_status.error {
            return Err(MesaError::LfsUpload {
                oid: obj_status.oid.clone(),
                message: error.message.clone(),
            });
        }

        if let Some(ref url) = obj_status.upload_url {
            let (file, _, _) = prepared
                .iter()
                .find(|(_, oid, _)| oid == &obj_status.oid)
                .ok_or_else(|| MesaError::LfsUpload {
                    oid: obj_status.oid.clone(),
                    message: "File not found for OID".to_owned(),
                })?;

            upload_to_s3(url, &file.content).await?;
        }
    }

    // 4. Create commit with LFS pointers
    let commit_files: Vec<CommitFileChange> = prepared
        .iter()
        .map(|(f, oid, size)| CommitFileChange::lfs(&f.path, oid, *size))
        .collect();

    let commit_req = CreateCommitWithLfsRequest {
        branch,
        message,
        author,
        files: commit_files,
        base_sha,
    };

    // Use the commits resource with the LFS-aware request
    client
        .commits(&org, &repo)
        .create_with_lfs(&commit_req)
        .await
}

/// Upload content to S3 using a pre-signed URL.
async fn upload_to_s3(url: &str, content: &[u8]) -> Result<(), MesaError> {
    // Use reqwest directly for S3 uploads (it's already a dependency when reqwest-client is enabled)
    #[cfg(feature = "reqwest-client")]
    {
        let client = reqwest::Client::new();
        let response = client
            .put(url)
            .body(content.to_vec())
            .header("Content-Length", content.len().to_string())
            .send()
            .await
            .map_err(|e| MesaError::LfsUpload {
                oid: String::new(),
                message: format!("S3 upload request failed: {e}"),
            })?;

        if !response.status().is_success() {
            return Err(MesaError::LfsUpload {
                oid: String::new(),
                message: format!("S3 upload failed: {}", response.status()),
            });
        }
        Ok(())
    }

    #[cfg(not(feature = "reqwest-client"))]
    {
        // For non-reqwest clients, return an error indicating manual upload is needed
        let _ = (url, content);
        Err(MesaError::LfsUpload {
            oid: String::new(),
            message: "S3 upload requires reqwest-client feature".to_owned(),
        })
    }
}