use crate::errors::SmallPictError;
use serde::{Deserialize, Serialize};
use std::fmt;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "lowercase")]
pub enum ImageFormat {
#[default]
Auto,
Avif,
Webp,
Jpeg,
Png,
}
impl fmt::Display for ImageFormat {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Auto => write!(f, "auto"),
Self::Avif => write!(f, "avif"),
Self::Webp => write!(f, "webp"),
Self::Jpeg => write!(f, "jpeg"),
Self::Png => write!(f, "png"),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "lowercase")]
pub enum FitMode {
#[default]
Cover,
Contain,
Inside,
Outside,
}
impl fmt::Display for FitMode {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Cover => write!(f, "cover"),
Self::Contain => write!(f, "contain"),
Self::Inside => write!(f, "inside"),
Self::Outside => write!(f, "outside"),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "lowercase")]
pub enum FallbackMode {
#[default]
Throw,
Passthrough,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "lowercase")]
pub enum CompressionMode {
#[default]
Lossy,
Extreme,
Lossless,
Auto,
}
impl fmt::Display for CompressionMode {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Lossy => write!(f, "lossy"),
Self::Extreme => write!(f, "extreme"),
Self::Lossless => write!(f, "lossless"),
Self::Auto => write!(f, "auto"),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
#[serde(rename_all = "lowercase")]
pub enum PurgeType {
#[default]
Url,
All,
}
impl fmt::Display for PurgeType {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Url => write!(f, "url"),
Self::All => write!(f, "all"),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OptimizeOptions {
#[serde(skip_serializing_if = "Option::is_none")]
pub format: Option<ImageFormat>,
#[serde(skip_serializing_if = "Option::is_none")]
pub quality: Option<u8>,
#[serde(skip_serializing_if = "Option::is_none")]
pub max_width: Option<u32>,
#[serde(skip_serializing_if = "Option::is_none")]
pub max_height: Option<u32>,
#[serde(skip_serializing_if = "Option::is_none")]
pub max_dimension: Option<u32>,
#[serde(skip_serializing_if = "Option::is_none")]
pub fit: Option<FitMode>,
#[serde(skip_serializing_if = "Option::is_none")]
pub mode: Option<CompressionMode>,
#[deprecated(note = "use mode")]
#[serde(skip_serializing)]
pub lossless: Option<bool>,
pub strip_metadata: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub filename: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub mime_type: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub content_type: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub folder: Option<String>,
#[serde(skip)]
pub idempotency_key: Option<String>,
}
#[allow(deprecated)]
impl Default for OptimizeOptions {
fn default() -> Self {
Self {
format: Some(ImageFormat::Auto),
quality: None,
max_width: None,
max_height: None,
max_dimension: None,
fit: Some(FitMode::Cover),
mode: None,
lossless: Some(false),
strip_metadata: true,
filename: None,
mime_type: None,
content_type: None,
folder: None,
idempotency_key: None,
}
}
}
impl OptimizeOptions {
pub fn builder() -> OptimizeOptionsBuilder {
OptimizeOptionsBuilder::default()
}
#[allow(deprecated)]
pub(crate) fn wire_mode(&self) -> Result<Option<CompressionMode>, SmallPictError> {
match (self.mode, self.lossless == Some(true)) {
(Some(m), true) if m != CompressionMode::Lossless => Err(SmallPictError::Validation {
message: format!(
"lossless = true contradicts mode = \"{}\"; set only mode",
m
),
details: None,
}),
(None, true) => Ok(Some(CompressionMode::Lossless)),
(m, _) => Ok(m),
}
}
}
pub(crate) fn check_folder(folder: &str) -> Result<(), SmallPictError> {
let segments: Vec<&str> = folder.split('/').collect();
let problem = if segments.iter().any(|s| s.is_empty()) {
Some("must not contain empty segments (leading, trailing or double '/')")
} else if segments.contains(&"..") {
Some("must not contain '..' segments")
} else if segments.len() > 3 {
Some("must have at most 3 segments")
} else {
None
};
match problem {
Some(p) => Err(SmallPictError::Validation {
message: format!("invalid folder {:?}: {}", folder, p),
details: None,
}),
None => Ok(()),
}
}
#[derive(Debug, Default, Clone)]
pub struct OptimizeOptionsBuilder {
options: OptimizeOptions,
}
impl OptimizeOptionsBuilder {
pub fn format(mut self, format: ImageFormat) -> Self {
self.options.format = Some(format);
self
}
pub fn quality(mut self, quality: u8) -> Self {
self.options.quality = Some(quality.clamp(1, 100));
self
}
pub fn max_width(mut self, width: u32) -> Self {
self.options.max_width = Some(width);
self
}
pub fn max_height(mut self, height: u32) -> Self {
self.options.max_height = Some(height);
self
}
pub fn max_dimension(mut self, dimension: u32) -> Self {
self.options.max_dimension = Some(dimension);
self
}
pub fn fit(mut self, fit: FitMode) -> Self {
self.options.fit = Some(fit);
self
}
pub fn mode(mut self, mode: CompressionMode) -> Self {
self.options.mode = Some(mode);
self
}
#[deprecated(note = "use mode")]
#[allow(deprecated)]
pub fn lossless(mut self, lossless: bool) -> Self {
self.options.lossless = Some(lossless);
self
}
pub fn strip_metadata(mut self, strip: bool) -> Self {
self.options.strip_metadata = strip;
self
}
pub fn filename(mut self, name: impl Into<String>) -> Self {
self.options.filename = Some(name.into());
self
}
pub fn mime_type(mut self, mime: impl Into<String>) -> Self {
self.options.mime_type = Some(mime.into());
self
}
pub fn content_type(mut self, ct: impl Into<String>) -> Self {
self.options.content_type = Some(ct.into());
self
}
pub fn folder(mut self, folder: impl Into<String>) -> Self {
self.options.folder = Some(folder.into());
self
}
pub fn idempotency_key(mut self, key: impl Into<String>) -> Self {
self.options.idempotency_key = Some(key.into());
self
}
pub fn build(self) -> OptimizeOptions {
self.options
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OptimizeResult {
pub job_id: String,
pub status: String,
pub url: String,
pub format: String,
pub original_size: u64,
pub compressed_size: u64,
pub bytes_saved: u64,
pub savings_percentage: f64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub mode_applied: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub quality_applied: Option<u32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub folder: Option<String>,
#[serde(skip)]
pub data: Option<Vec<u8>>,
}
impl OptimizeResult {
pub(crate) fn from_status(st: JobStatusResult, original_size: u64) -> Self {
let bytes_saved = st.bytes_saved.unwrap_or(0).max(0) as u64;
let savings_percentage = if original_size > 0 {
(bytes_saved as f64 / original_size as f64 * 10_000.0).round() / 100.0
} else {
0.0
};
Self {
job_id: st.job_id,
status: st.status,
url: st.url.unwrap_or_default(),
format: st.format.unwrap_or_default(),
original_size,
compressed_size: original_size.saturating_sub(bytes_saved),
bytes_saved,
savings_percentage,
mode_applied: st.mode_applied,
quality_applied: st.quality_applied,
folder: st.folder,
data: None,
}
}
}
pub(crate) fn passthrough(data: &[u8], mime_type: &str) -> OptimizeResult {
OptimizeResult {
job_id: "fallback-passthrough".to_string(),
status: "completed".to_string(),
url: String::new(),
format: mime_type.trim_start_matches("image/").to_string(),
original_size: data.len() as u64,
compressed_size: data.len() as u64,
bytes_saved: 0,
savings_percentage: 0.0,
mode_applied: None,
quality_applied: None,
folder: None,
data: Some(data.to_vec()),
}
}
#[derive(Debug, Deserialize)]
pub(crate) struct QueuedJob {
pub job_id: String,
pub upload_url: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct QuotaResponse {
pub plan: String,
pub bytes_used: u64,
pub quota_limit: u64,
pub quota_percentage: f64,
#[serde(skip_serializing_if = "Option::is_none")]
pub cdn_egress_used_bytes: Option<u64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub cdn_egress_quota_bytes: Option<u64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub active_keys_count: Option<u32>,
#[serde(skip_serializing_if = "Option::is_none")]
pub active_sites_count: Option<u32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub capacity: Option<Capacity>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Capacity {
pub period_end: Option<String>,
pub storage: Option<CapacityStorage>,
pub cdn: Option<CapacityCdn>,
pub booster: CapacityBooster,
pub lapse: Option<CapacityLapse>,
pub manage_url: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CapacityStorage {
pub limit_bytes: i64,
pub used_bytes: i64,
pub base_bytes: i64,
pub addon_blocks: i64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CapacityCdn {
pub limit_bytes: i64,
pub used_bytes: i64,
pub status: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CapacityBooster {
pub active: bool,
pub wp_quota_bytes: Option<i64>,
pub api_transforms: Option<i64>,
pub cdn_bytes: Option<i64>,
pub next_expiry: Option<BoosterExpiry>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BoosterExpiry {
pub kind: String,
pub units: i64,
pub expires_at: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CapacityLapse {
pub stage: String,
pub delete_after: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PurgeResponse {
pub message: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct JobStatusResult {
pub job_id: String,
pub status: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub url: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub format: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub bytes_saved: Option<i64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub error: Option<serde_json::Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub updated_at: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub mode_applied: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub quality_applied: Option<u32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub folder: Option<String>,
}