articles_rs/databases/

article_repository.rs

//! Article repository module for database operations
//! 
//! This module provides the database model and repository implementation for articles.
//! It handles CRUD operations and queries for articles stored in a PostgreSQL database.

use async_trait::async_trait;
use chrono::{DateTime, Utc};
use sqlx::{
    postgres::{PgPool, PgRow},
    Error as SqlxError, FromRow, Row,
};
use std::collections::HashMap;
use uuid::Uuid;

use crate::postgres_repository::PostgresRepository;

/// Database model representing an article
///
/// Contains all fields that map to the articles table in the database.
pub struct DbArticle {
    pub id: Option<Uuid>,
    pub title: String,
    pub hero_image: String,
    pub slug: String,
    pub description: String,
    pub author: String,
    pub status: String,
    pub created: DateTime<Utc>,
    pub content: String,
    pub source: String,
    pub published: Option<DateTime<Utc>>,
}


impl DbArticle {
    /// Creates a new `DbArticle` with basic required fields
    ///
    /// # Arguments
    /// * `title` - Article title
    /// * `slug` - URL-friendly slug
    /// * `description` - Brief description
    /// * `author` - Article author
    pub fn new(title: &str, slug: &str, description: &str, author: &str) -> Self {
        let now = Utc::now();
        DbArticle {
            id: None,
            title: title.to_string(),
            hero_image: "".to_string(),
            slug: slug.to_string(),
            description: description.to_string(),
            author: author.to_string(),
            status: "NEW".to_string(),
            created: now,
            content: String::new(),
            source: String::new(),
            published: None,
        }
    }
}

/// Implementation for converting database rows to DbArticle
impl<'r> FromRow<'r, PgRow> for DbArticle {
    fn from_row(row: &'r PgRow) -> Result<Self, sqlx::Error> {
        let row_id = row.try_get("id").ok();
        let hero: String = row.try_get("hero_image").unwrap_or_else(|_| String::new());
        let published = row.try_get::<chrono::NaiveDateTime, _>("published")
            .ok()
            .map(|naive_date| DateTime::<Utc>::from_naive_utc_and_offset(naive_date, Utc));
        Ok(DbArticle {
            id: row_id,
            title: row.try_get("title")?,
            hero_image: hero,
            slug: row.try_get("slug")?,
            description: row.try_get("description")?,
            author: row.try_get("author")?,
            status: row.try_get("status")?,
            created: row
                .try_get::<DateTime<Utc>, _>("created")
                .unwrap_or_else(|_| {
                    // Handle conversion of naive datetime to UTC
                    let naive_date: chrono::NaiveDateTime = row.try_get("created").unwrap();
                    DateTime::<Utc>::from_naive_utc_and_offset(naive_date, Utc)
                }),
            content: row.try_get("content")?,
            source: row.try_get("source").unwrap_or_default(),
            published: published,
        })
    }
}

/// Repository for handling article database operations
pub struct ArticleRepository {
    /// Database connection pool
    pool: PgPool,
}

impl ArticleRepository {
    /// Creates a new `ArticleRepository` instance
    ///
    /// # Arguments
    /// * `pool` - PostgreSQL connection pool
    pub fn new(pool: PgPool) -> Self {
        Self { pool }
    }
}

/// Implementation of PostgresRepository trait for ArticleRepository
#[async_trait]
impl PostgresRepository for ArticleRepository {
    type Error = SqlxError;
    type Item = DbArticle;

    /// Creates a new article in the database
    ///
    /// # Arguments
    /// * `article` - Article to create
    ///
    /// # Returns
    /// The UUID of the created article
    async fn create(&self, article: &Self::Item) -> Result<Uuid, Self::Error> {
        let row = sqlx::query(
            r#"
                INSERT INTO articles (title, slug, source, description, author, status, created, content, published)
                VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
                RETURNING id
                "#,
        )
        .bind(&article.title)
        .bind(&article.slug)
        .bind(&article.source)
        .bind(&article.description)
        .bind(&article.author)
        .bind(&article.status)
        .bind(article.created)
        .bind(&article.content)
        .fetch_one(&self.pool)
        .await?;

        let id: Uuid = row.try_get("id")?;
        Ok(id)
    }

    /// Updates an existing article in the database
    ///
    /// # Arguments
    /// * `article` - Article with updated fields
    ///
    /// # Returns
    /// Error if article not found
    async fn update(&self, article: &Self::Item) -> Result<(), Self::Error> {
        let affected_rows = sqlx::query(
            r#"
                UPDATE articles
                SET title = $1, slug = $2, author = $3, status = $4, created = $5, content = $6, description = $7, source = $8, published = $9
                WHERE id = $10
                "#,
        )
        .bind(&article.title)
        .bind(&article.slug)
        .bind(&article.author)
        .bind(&article.status)
        .bind(article.created)
        .bind(&article.content)
        .bind(&article.description)
        .bind(&article.source)
        .bind(article.published)
        .bind(article.id)
        .execute(&self.pool)
        .await?
        .rows_affected();

        if affected_rows == 0 {
            return Err(SqlxError::RowNotFound);
        }

        Ok(())
    }

    /// Deletes an article from the database
    ///
    /// # Arguments
    /// * `id` - UUID of article to delete
    ///
    /// # Returns
    /// Error if article not found
    async fn delete(&self, id: Uuid) -> Result<(), Self::Error> {
        let affected_rows = sqlx::query(
            r#"
                DELETE FROM articles
                WHERE id = $1
                "#,
        )
        .bind(id)
        .execute(&self.pool)
        .await?
        .rows_affected();

        if affected_rows == 0 {
            return Err(SqlxError::RowNotFound);
        }

        Ok(())
    }

    /// Deletes all articles matching the provided filters
    /// 
    /// Currently not implemented
    async fn delete_all(
        &self,
        _filters: Option<HashMap<String, String>>,
    ) -> Result<(), Self::Error> {
        tracing::warn!("delete_all not implemented");
        return Err(SqlxError::RowNotFound);
    }

    /// Finds an article by its UUID
    ///
    /// # Arguments
    /// * `id` - UUID to search for
    ///
    /// # Returns
    /// The article if found, None otherwise
    async fn find_by_id(&self, id: Uuid) -> Result<Option<Self::Item>, Self::Error> {
        let row_result = sqlx::query(
            "SELECT articles.id, title, slug, description, author, status, created, content,
            (SELECT image_path FROM article_images WHERE article_images.article_id = articles.id LIMIT 1) as hero_image,
            source,
            published
            FROM articles WHERE articles.id = $1",
        )
        .bind(id)
        .fetch_optional(&self.pool)
        .await?;

        match row_result {
            Some(row) => {
                let article = DbArticle::from_row(&row)?;
                Ok(Some(article))
            }
            None => Ok(None),
        }
    }

    /// Finds an article by its slug
    ///
    /// # Arguments
    /// * `slug` - Slug to search for
    ///
    /// # Returns
    /// The article if found, None otherwise
    async fn find_by_name(&self, slug: String) -> Result<Option<Self::Item>, Self::Error> {
        let sql = "SELECT articles.id, title, slug, description, author, status, created, content,
                            (SELECT image_path FROM article_images WHERE article_images.article_id = articles.id LIMIT 1) as hero_image,
                            source,
                            published
                            FROM articles WHERE articles.slug = $1";
        let row_result = sqlx::query(sql)
            .bind(slug.clone())
            .fetch_optional(&self.pool)
            .await?;

        match row_result {
            Some(row) => {
                let article = DbArticle::from_row(&row)?;
                Ok(Some(article))
            }
            None => Ok(None),
        }
    }

    /// Lists articles with optional filters
    ///
    /// # Arguments
    /// * `filters` - Optional HashMap of column names to values to filter by
    ///
    /// # Returns
    /// Vector of matching articles
    async fn list(
        &self,
        filters: Option<HashMap<String, String>>,
    ) -> Result<Vec<Self::Item>, Self::Error> {
        // Build base query
        let mut query = String::from(
            "SELECT articles.id, title, slug, description, author, status, created, content, source, published,
                                        (SELECT image_path FROM article_images WHERE article_images.article_id = articles.id LIMIT 1) as hero_image
                                        FROM articles",
        );
        let mut params: Vec<String> = Vec::new();
        let mut param_count = 1;

        // Add WHERE clause if filters are provided
        if let Some(filter_map) = filters {
            if !filter_map.is_empty() {
                query.push_str(" WHERE ");
                for (column, value) in filter_map {
                    if param_count > 1 {
                        query.push_str(" AND ");
                    }
                    query.push_str(&format!("{} = ${}", column, param_count));
                    params.push(value);
                    param_count += 1;
                }
            }
        }

        // Add ORDER BY clause
        query.push_str(" ORDER BY created DESC");
        let mut query_builder = sqlx::query(&query);
        
        // Bind parameters, handling UUIDs specially
        for param in params {
            // Try parsing as UUID first, if it fails, bind as a string
            if let Ok(uuid) = sqlx::types::Uuid::parse_str(&param) {
                query_builder = query_builder.bind(uuid);
            } else {
                query_builder = query_builder.bind(param);
            }
        }

        // Execute query and convert results to DbArticles
        let articles = query_builder
            .fetch_all(&self.pool)
            .await?
            .into_iter()
            .map(|row| DbArticle::from_row(&row))
            .collect::<Result<Vec<_>, _>>()?;

        Ok(articles)
    }
}