kreuzberg 4.0.0.pre.rc.13 → 4.0.0.pre.rc.14

data/vendor/kreuzberg/src/api/error.rs

@@ -1,81 +1,81 @@
-//! API error handling.
-
-use axum::{
-    Json,
-    http::StatusCode,
-    response::{IntoResponse, Response},
-};
-
-use crate::error::KreuzbergError;
-
-use super::types::ErrorResponse;
-
-/// API-specific error wrapper.
-#[derive(Debug)]
-pub struct ApiError {
-    /// HTTP status code
-    pub status: StatusCode,
-    /// Error response body
-    pub body: ErrorResponse,
-}
-
-impl ApiError {
-    /// Create a new API error.
-    pub fn new(status: StatusCode, error: KreuzbergError) -> Self {
-        let error_type = match &error {
-            KreuzbergError::Validation { .. } => "ValidationError",
-            KreuzbergError::Parsing { .. } => "ParsingError",
-            KreuzbergError::Ocr { .. } => "OCRError",
-            KreuzbergError::Io(_) => "IOError",
-            KreuzbergError::Cache { .. } => "CacheError",
-            KreuzbergError::ImageProcessing { .. } => "ImageProcessingError",
-            KreuzbergError::Serialization { .. } => "SerializationError",
-            KreuzbergError::MissingDependency(_) => "MissingDependencyError",
-            KreuzbergError::Plugin { .. } => "PluginError",
-            KreuzbergError::LockPoisoned(_) => "LockPoisonedError",
-            KreuzbergError::UnsupportedFormat(_) => "UnsupportedFormatError",
-            KreuzbergError::Other(_) => "Error",
-        };
-
-        Self {
-            status,
-            body: ErrorResponse {
-                error_type: error_type.to_string(),
-                message: error.to_string(),
-                traceback: None,
-                status_code: status.as_u16(),
-            },
-        }
-    }
-
-    /// Create a validation error (400).
-    pub fn validation(error: KreuzbergError) -> Self {
-        Self::new(StatusCode::BAD_REQUEST, error)
-    }
-
-    /// Create an unprocessable entity error (422).
-    pub fn unprocessable(error: KreuzbergError) -> Self {
-        Self::new(StatusCode::UNPROCESSABLE_ENTITY, error)
-    }
-
-    /// Create an internal server error (500).
-    pub fn internal(error: KreuzbergError) -> Self {
-        Self::new(StatusCode::INTERNAL_SERVER_ERROR, error)
-    }
-}
-
-impl IntoResponse for ApiError {
-    fn into_response(self) -> Response {
-        (self.status, Json(self.body)).into_response()
-    }
-}
-
-impl From<KreuzbergError> for ApiError {
-    fn from(error: KreuzbergError) -> Self {
-        match &error {
-            KreuzbergError::Validation { .. } => Self::validation(error),
-            KreuzbergError::Parsing { .. } | KreuzbergError::Ocr { .. } => Self::unprocessable(error),
-            _ => Self::internal(error),
-        }
-    }
-}
+//! API error handling.
+
+use axum::{
+    Json,
+    http::StatusCode,
+    response::{IntoResponse, Response},
+};
+
+use crate::error::KreuzbergError;
+
+use super::types::ErrorResponse;
+
+/// API-specific error wrapper.
+#[derive(Debug)]
+pub struct ApiError {
+    /// HTTP status code
+    pub status: StatusCode,
+    /// Error response body
+    pub body: ErrorResponse,
+}
+
+impl ApiError {
+    /// Create a new API error.
+    pub fn new(status: StatusCode, error: KreuzbergError) -> Self {
+        let error_type = match &error {
+            KreuzbergError::Validation { .. } => "ValidationError",
+            KreuzbergError::Parsing { .. } => "ParsingError",
+            KreuzbergError::Ocr { .. } => "OCRError",
+            KreuzbergError::Io(_) => "IOError",
+            KreuzbergError::Cache { .. } => "CacheError",
+            KreuzbergError::ImageProcessing { .. } => "ImageProcessingError",
+            KreuzbergError::Serialization { .. } => "SerializationError",
+            KreuzbergError::MissingDependency(_) => "MissingDependencyError",
+            KreuzbergError::Plugin { .. } => "PluginError",
+            KreuzbergError::LockPoisoned(_) => "LockPoisonedError",
+            KreuzbergError::UnsupportedFormat(_) => "UnsupportedFormatError",
+            KreuzbergError::Other(_) => "Error",
+        };
+
+        Self {
+            status,
+            body: ErrorResponse {
+                error_type: error_type.to_string(),
+                message: error.to_string(),
+                traceback: None,
+                status_code: status.as_u16(),
+            },
+        }
+    }
+
+    /// Create a validation error (400).
+    pub fn validation(error: KreuzbergError) -> Self {
+        Self::new(StatusCode::BAD_REQUEST, error)
+    }
+
+    /// Create an unprocessable entity error (422).
+    pub fn unprocessable(error: KreuzbergError) -> Self {
+        Self::new(StatusCode::UNPROCESSABLE_ENTITY, error)
+    }
+
+    /// Create an internal server error (500).
+    pub fn internal(error: KreuzbergError) -> Self {
+        Self::new(StatusCode::INTERNAL_SERVER_ERROR, error)
+    }
+}
+
+impl IntoResponse for ApiError {
+    fn into_response(self) -> Response {
+        (self.status, Json(self.body)).into_response()
+    }
+}
+
+impl From<KreuzbergError> for ApiError {
+    fn from(error: KreuzbergError) -> Self {
+        match &error {
+            KreuzbergError::Validation { .. } => Self::validation(error),
+            KreuzbergError::Parsing { .. } | KreuzbergError::Ocr { .. } => Self::unprocessable(error),
+            _ => Self::internal(error),
+        }
+    }
+}

data/vendor/kreuzberg/src/api/handlers.rs

@@ -1,199 +1,199 @@
-//! API request handlers.
-
-use axum::{
-    Json,
-    extract::{Multipart, State},
-};
-
-use crate::{batch_extract_bytes, cache, extract_bytes};
-
-use super::{
-    error::ApiError,
-    types::{ApiState, CacheClearResponse, CacheStatsResponse, ExtractResponse, HealthResponse, InfoResponse},
-};
-
-/// Extract endpoint handler.
-///
-/// POST /extract
-///
-/// Accepts multipart form data with:
-/// - `files`: One or more files to extract
-/// - `config` (optional): JSON extraction configuration (overrides server defaults)
-///
-/// Returns a list of extraction results, one per file.
-///
-/// # Size Limits
-///
-/// Request body size limits are enforced at the router layer via `RequestBodyLimitLayer`.
-/// Default limits:
-/// - Total request body: 100 MB (all files + form data combined)
-/// - Individual multipart fields: Controlled by Axum's default multipart limits
-///
-/// If a request exceeds the size limit, it will be rejected with HTTP 413 (Payload Too Large).
-///
-/// The server's default config (loaded from kreuzberg.toml/yaml/json via discovery)
-/// is used as the base, and any per-request config overrides those defaults.
-pub async fn extract_handler(
-    State(state): State<ApiState>,
-    mut multipart: Multipart,
-) -> Result<Json<ExtractResponse>, ApiError> {
-    let mut files = Vec::new();
-    let mut config = (*state.default_config).clone();
-
-    while let Some(field) = multipart
-        .next_field()
-        .await
-        .map_err(|e| ApiError::validation(crate::error::KreuzbergError::validation(e.to_string())))?
-    {
-        let field_name = field.name().unwrap_or("").to_string();
-
-        match field_name.as_str() {
-            "files" => {
-                let file_name = field.file_name().map(|s| s.to_string());
-                let content_type = field.content_type().map(|s| s.to_string());
-                let data = field
-                    .bytes()
-                    .await
-                    .map_err(|e| ApiError::validation(crate::error::KreuzbergError::validation(e.to_string())))?;
-
-                let mime_type = content_type.unwrap_or_else(|| "application/octet-stream".to_string());
-
-                files.push((data.to_vec(), mime_type, file_name));
-            }
-            "config" => {
-                let config_str = field
-                    .text()
-                    .await
-                    .map_err(|e| ApiError::validation(crate::error::KreuzbergError::validation(e.to_string())))?;
-
-                config = serde_json::from_str(&config_str).map_err(|e| {
-                    ApiError::validation(crate::error::KreuzbergError::validation(format!(
-                        "Invalid extraction configuration: {}",
-                        e
-                    )))
-                })?;
-            }
-            _ => {}
-        }
-    }
-
-    if files.is_empty() {
-        return Err(ApiError::validation(crate::error::KreuzbergError::validation(
-            "No files provided for extraction",
-        )));
-    }
-
-    if files.len() == 1 {
-        let (data, mime_type, _file_name) = files
-            .into_iter()
-            .next()
-            .expect("files.len() == 1 guarantees one element exists");
-        let result = extract_bytes(&data, mime_type.as_str(), &config).await?;
-        return Ok(Json(vec![result]));
-    }
-
-    let files_data: Vec<(Vec<u8>, String)> = files.into_iter().map(|(data, mime, _name)| (data, mime)).collect();
-
-    let file_refs: Vec<(&[u8], &str)> = files_data
-        .iter()
-        .map(|(data, mime)| (data.as_slice(), mime.as_str()))
-        .collect();
-
-    let results = batch_extract_bytes(file_refs, &config).await?;
-    Ok(Json(results))
-}
-
-/// Health check endpoint handler.
-///
-/// GET /health
-pub async fn health_handler() -> Json<HealthResponse> {
-    Json(HealthResponse {
-        status: "healthy".to_string(),
-        version: env!("CARGO_PKG_VERSION").to_string(),
-    })
-}
-
-/// Server info endpoint handler.
-///
-/// GET /info
-pub async fn info_handler() -> Json<InfoResponse> {
-    Json(InfoResponse {
-        version: env!("CARGO_PKG_VERSION").to_string(),
-        rust_backend: true,
-    })
-}
-
-/// Cache stats endpoint handler.
-///
-/// GET /cache/stats
-///
-/// # Errors
-///
-/// Returns `ApiError::Internal` if:
-/// - Current directory cannot be determined
-/// - Cache directory path contains non-UTF8 characters
-/// - Cache metadata retrieval fails
-pub async fn cache_stats_handler() -> Result<Json<CacheStatsResponse>, ApiError> {
-    let cache_dir = std::env::current_dir()
-        .map_err(|e| {
-            ApiError::internal(crate::error::KreuzbergError::Other(format!(
-                "Failed to get current directory: {}",
-                e
-            )))
-        })?
-        .join(".kreuzberg");
-
-    let cache_dir_str = cache_dir.to_str().ok_or_else(|| {
-        ApiError::internal(crate::error::KreuzbergError::Other(format!(
-            "Cache directory path contains non-UTF8 characters: {}",
-            cache_dir.display()
-        )))
-    })?;
-
-    let stats = cache::get_cache_metadata(cache_dir_str).map_err(ApiError::internal)?;
-
-    Ok(Json(CacheStatsResponse {
-        directory: cache_dir.to_string_lossy().to_string(),
-        total_files: stats.total_files,
-        total_size_mb: stats.total_size_mb,
-        available_space_mb: stats.available_space_mb,
-        oldest_file_age_days: stats.oldest_file_age_days,
-        newest_file_age_days: stats.newest_file_age_days,
-    }))
-}
-
-/// Cache clear endpoint handler.
-///
-/// DELETE /cache/clear
-///
-/// # Errors
-///
-/// Returns `ApiError::Internal` if:
-/// - Current directory cannot be determined
-/// - Cache directory path contains non-UTF8 characters
-/// - Cache clearing operation fails
-pub async fn cache_clear_handler() -> Result<Json<CacheClearResponse>, ApiError> {
-    let cache_dir = std::env::current_dir()
-        .map_err(|e| {
-            ApiError::internal(crate::error::KreuzbergError::Other(format!(
-                "Failed to get current directory: {}",
-                e
-            )))
-        })?
-        .join(".kreuzberg");
-
-    let cache_dir_str = cache_dir.to_str().ok_or_else(|| {
-        ApiError::internal(crate::error::KreuzbergError::Other(format!(
-            "Cache directory path contains non-UTF8 characters: {}",
-            cache_dir.display()
-        )))
-    })?;
-
-    let (removed_files, freed_mb) = cache::clear_cache_directory(cache_dir_str).map_err(ApiError::internal)?;
-
-    Ok(Json(CacheClearResponse {
-        directory: cache_dir.to_string_lossy().to_string(),
-        removed_files,
-        freed_mb,
-    }))
-}
+//! API request handlers.
+
+use axum::{
+    Json,
+    extract::{Multipart, State},
+};
+
+use crate::{batch_extract_bytes, cache, extract_bytes};
+
+use super::{
+    error::ApiError,
+    types::{ApiState, CacheClearResponse, CacheStatsResponse, ExtractResponse, HealthResponse, InfoResponse},
+};
+
+/// Extract endpoint handler.
+///
+/// POST /extract
+///
+/// Accepts multipart form data with:
+/// - `files`: One or more files to extract
+/// - `config` (optional): JSON extraction configuration (overrides server defaults)
+///
+/// Returns a list of extraction results, one per file.
+///
+/// # Size Limits
+///
+/// Request body size limits are enforced at the router layer via `RequestBodyLimitLayer`.
+/// Default limits:
+/// - Total request body: 100 MB (all files + form data combined)
+/// - Individual multipart fields: Controlled by Axum's default multipart limits
+///
+/// If a request exceeds the size limit, it will be rejected with HTTP 413 (Payload Too Large).
+///
+/// The server's default config (loaded from kreuzberg.toml/yaml/json via discovery)
+/// is used as the base, and any per-request config overrides those defaults.
+pub async fn extract_handler(
+    State(state): State<ApiState>,
+    mut multipart: Multipart,
+) -> Result<Json<ExtractResponse>, ApiError> {
+    let mut files = Vec::new();
+    let mut config = (*state.default_config).clone();
+
+    while let Some(field) = multipart
+        .next_field()
+        .await
+        .map_err(|e| ApiError::validation(crate::error::KreuzbergError::validation(e.to_string())))?
+    {
+        let field_name = field.name().unwrap_or("").to_string();
+
+        match field_name.as_str() {
+            "files" => {
+                let file_name = field.file_name().map(|s| s.to_string());
+                let content_type = field.content_type().map(|s| s.to_string());
+                let data = field
+                    .bytes()
+                    .await
+                    .map_err(|e| ApiError::validation(crate::error::KreuzbergError::validation(e.to_string())))?;
+
+                let mime_type = content_type.unwrap_or_else(|| "application/octet-stream".to_string());
+
+                files.push((data.to_vec(), mime_type, file_name));
+            }
+            "config" => {
+                let config_str = field
+                    .text()
+                    .await
+                    .map_err(|e| ApiError::validation(crate::error::KreuzbergError::validation(e.to_string())))?;
+
+                config = serde_json::from_str(&config_str).map_err(|e| {
+                    ApiError::validation(crate::error::KreuzbergError::validation(format!(
+                        "Invalid extraction configuration: {}",
+                        e
+                    )))
+                })?;
+            }
+            _ => {}
+        }
+    }
+
+    if files.is_empty() {
+        return Err(ApiError::validation(crate::error::KreuzbergError::validation(
+            "No files provided for extraction",
+        )));
+    }
+
+    if files.len() == 1 {
+        let (data, mime_type, _file_name) = files
+            .into_iter()
+            .next()
+            .expect("files.len() == 1 guarantees one element exists");
+        let result = extract_bytes(&data, mime_type.as_str(), &config).await?;
+        return Ok(Json(vec![result]));
+    }
+
+    let files_data: Vec<(Vec<u8>, String)> = files.into_iter().map(|(data, mime, _name)| (data, mime)).collect();
+
+    let file_refs: Vec<(&[u8], &str)> = files_data
+        .iter()
+        .map(|(data, mime)| (data.as_slice(), mime.as_str()))
+        .collect();
+
+    let results = batch_extract_bytes(file_refs, &config).await?;
+    Ok(Json(results))
+}
+
+/// Health check endpoint handler.
+///
+/// GET /health
+pub async fn health_handler() -> Json<HealthResponse> {
+    Json(HealthResponse {
+        status: "healthy".to_string(),
+        version: env!("CARGO_PKG_VERSION").to_string(),
+    })
+}
+
+/// Server info endpoint handler.
+///
+/// GET /info
+pub async fn info_handler() -> Json<InfoResponse> {
+    Json(InfoResponse {
+        version: env!("CARGO_PKG_VERSION").to_string(),
+        rust_backend: true,
+    })
+}
+
+/// Cache stats endpoint handler.
+///
+/// GET /cache/stats
+///
+/// # Errors
+///
+/// Returns `ApiError::Internal` if:
+/// - Current directory cannot be determined
+/// - Cache directory path contains non-UTF8 characters
+/// - Cache metadata retrieval fails
+pub async fn cache_stats_handler() -> Result<Json<CacheStatsResponse>, ApiError> {
+    let cache_dir = std::env::current_dir()
+        .map_err(|e| {
+            ApiError::internal(crate::error::KreuzbergError::Other(format!(
+                "Failed to get current directory: {}",
+                e
+            )))
+        })?
+        .join(".kreuzberg");
+
+    let cache_dir_str = cache_dir.to_str().ok_or_else(|| {
+        ApiError::internal(crate::error::KreuzbergError::Other(format!(
+            "Cache directory path contains non-UTF8 characters: {}",
+            cache_dir.display()
+        )))
+    })?;
+
+    let stats = cache::get_cache_metadata(cache_dir_str).map_err(ApiError::internal)?;
+
+    Ok(Json(CacheStatsResponse {
+        directory: cache_dir.to_string_lossy().to_string(),
+        total_files: stats.total_files,
+        total_size_mb: stats.total_size_mb,
+        available_space_mb: stats.available_space_mb,
+        oldest_file_age_days: stats.oldest_file_age_days,
+        newest_file_age_days: stats.newest_file_age_days,
+    }))
+}
+
+/// Cache clear endpoint handler.
+///
+/// DELETE /cache/clear
+///
+/// # Errors
+///
+/// Returns `ApiError::Internal` if:
+/// - Current directory cannot be determined
+/// - Cache directory path contains non-UTF8 characters
+/// - Cache clearing operation fails
+pub async fn cache_clear_handler() -> Result<Json<CacheClearResponse>, ApiError> {
+    let cache_dir = std::env::current_dir()
+        .map_err(|e| {
+            ApiError::internal(crate::error::KreuzbergError::Other(format!(
+                "Failed to get current directory: {}",
+                e
+            )))
+        })?
+        .join(".kreuzberg");
+
+    let cache_dir_str = cache_dir.to_str().ok_or_else(|| {
+        ApiError::internal(crate::error::KreuzbergError::Other(format!(
+            "Cache directory path contains non-UTF8 characters: {}",
+            cache_dir.display()
+        )))
+    })?;
+
+    let (removed_files, freed_mb) = cache::clear_cache_directory(cache_dir_str).map_err(ApiError::internal)?;
+
+    Ok(Json(CacheClearResponse {
+        directory: cache_dir.to_string_lossy().to_string(),
+        removed_files,
+        freed_mb,
+    }))
+}