backbone_accounting/presentation/http/

journal_line_handler.rs

//! JournalLine REST handlers
//!
//! Generated by metaphor-schema. Do not edit manually.
//!
//! Uses Axum and backbone-core's BackboneCrudHandler for all 12 CRUD endpoints.

use std::collections::HashMap;
use std::sync::Arc;

use axum::Router;
use serde::{Deserialize, Serialize};
use uuid::Uuid;
use chrono::{DateTime, Utc};
use rust_decimal::Decimal;

// Backbone framework imports
use backbone_core::http::BackboneCrudHandler;

// Auth integration (optional)
#[cfg(feature = "auth")]
use backbone_auth::middleware::AuthContext;
#[cfg(feature = "auth")]
use backbone_auth::AuthMiddleware;

// Domain imports
use crate::domain::entity::*;
use crate::application::service::{JournalLineService, ServiceError};

// DTO imports
use crate::presentation::dto::{CreateJournalLineDto, UpdateJournalLineDto, PatchJournalLineDto, JournalLineResponseDto};


/// Application error type
#[derive(Debug, thiserror::Error)]
pub enum JournalLineError {
    #[error("Not found: {0}")]
    NotFound(String),
    #[error("Validation error: {0}")]
    Validation(String),
    #[error("Database error: {0}")]
    Database(String),
    #[error("Internal error: {0}")]
    Internal(String),
}

impl From<ServiceError> for JournalLineError {
    fn from(err: ServiceError) -> Self {
        match err {
            ServiceError::NotFound => Self::NotFound(err.to_string()),
            ServiceError::Validation(ref msg) => Self::Validation(msg.clone()),
            ServiceError::AlreadyExists(ref msg) => Self::Validation(msg.clone()),
            ServiceError::Repository(ref e) => Self::Database(e.to_string()),
            ServiceError::Internal(ref msg) => Self::Internal(msg.clone()),
            ServiceError::Violations(_) => Self::Validation(err.to_string()),
        }
    }
}

impl axum::response::IntoResponse for JournalLineError {
    fn into_response(self) -> axum::response::Response {
        use axum::http::StatusCode;
        use axum::Json;

        let (status, code) = match &self {
            Self::NotFound(_) => (StatusCode::NOT_FOUND, "JOURNALLINE_NOT_FOUND"),
            Self::Validation(_) => (StatusCode::BAD_REQUEST, "JOURNALLINE_VALIDATION_ERROR"),
            Self::Database(_) => (StatusCode::INTERNAL_SERVER_ERROR, "JOURNALLINE_DATABASE_ERROR"),
            Self::Internal(_) => (StatusCode::INTERNAL_SERVER_ERROR, "JOURNALLINE_INTERNAL_ERROR"),
        };

        let body = serde_json::json!({
            "success": false,
            "error": code,
            "message": self.to_string(),
        });

        (status, Json(body)).into_response()
    }
}

// =============================================================================
// Route Configuration
// =============================================================================

/// Create Axum router with all 16 Backbone endpoints for JournalLine.
///
/// # Routes
///
/// | Method | Path | Description |
/// |--------|------|-------------|
/// | GET | /journal_lines | List with pagination |
/// | POST | /journal_lines | Create new |
/// | GET | /journal_lines/:id | Get by ID |
/// | PUT | /journal_lines/:id | Full update |
/// | PATCH | /journal_lines/:id | Partial update |
/// | DELETE | /journal_lines/:id | Soft delete |
/// | POST | /journal_lines/bulk | Bulk create |
/// | POST | /journal_lines/upsert | Upsert |
/// | GET | /journal_lines/trash | List deleted |
/// | POST | /journal_lines/:id/restore | Restore |
/// | DELETE | /journal_lines/empty | Empty trash |
/// | GET | /journal_lines/:id/deleted | Get deleted by ID |
/// | DELETE | /journal_lines/trash/:id | Permanent delete from trash |
/// | GET | /journal_lines/count | Count active entities |
/// | GET | /journal_lines/trash/count | Count deleted entities |
///
/// # Example
///
/// ```text
/// let service = Arc::new(JournalLineService::with_repository(repository));
/// let router = create_journal_line_routes(service);
/// ```
pub fn create_journal_line_routes(service: Arc<JournalLineService>) -> Router {
    BackboneCrudHandler::<JournalLineService, JournalLine, CreateJournalLineDto, UpdateJournalLineDto, JournalLineResponseDto>::routes(
        service,
        "/journal_lines",
    )
}

/// Create Axum router with only the read (GET) endpoints for JournalLine.
///
/// Safe for public, unauthenticated exposure (e.g., reference data).
/// Mutations must be served separately via `create_journal_line_write_routes`,
/// typically wrapped in an auth middleware layer.
pub fn create_journal_line_read_routes(service: Arc<JournalLineService>) -> Router {
    BackboneCrudHandler::<JournalLineService, JournalLine, CreateJournalLineDto, UpdateJournalLineDto, JournalLineResponseDto>::read_routes(
        service,
        "/journal_lines",
    )
}

/// Create Axum router with only the write (mutation) endpoints for JournalLine.
///
/// These routes must NOT be publicly exposed. Wrap them with an auth
/// middleware before nesting into the application router.
///
/// # This is unguarded generic CRUD, not a validated write path
///
/// These are plain create/update/patch/delete mutations over the entity row —
/// they bypass all business invariants. If the module exposes a validated write
/// service (e.g. a command router over its domain engine), serve THAT instead
/// for any mutation that must respect domain rules.
pub fn create_journal_line_write_routes(service: Arc<JournalLineService>) -> Router {
    BackboneCrudHandler::<JournalLineService, JournalLine, CreateJournalLineDto, UpdateJournalLineDto, JournalLineResponseDto>::write_routes(
        service,
        "/journal_lines",
    )
}

/// Create authenticated routes with auth middleware.
///
/// Requires the `auth` feature flag. The `AuthMiddleware` implementation
/// is responsible for extracting and validating tokens, then providing
/// an `AuthContext` via request extensions.
#[cfg(feature = "auth")]
pub fn create_protected_journal_line_routes<A: AuthMiddleware + Send + Sync + 'static>(
    service: Arc<JournalLineService>,
    auth: Arc<A>,
) -> Router {
    use axum::middleware;
    use axum::response::IntoResponse;

    let auth_layer = auth.clone();
    create_journal_line_routes(service)
        .layer(middleware::from_fn(move |mut req: axum::extract::Request, next: axum::middleware::Next| {
            let auth = auth_layer.clone();
            async move {
                let token = req.headers()
                    .get(axum::http::header::AUTHORIZATION)
                    .and_then(|h| h.to_str().ok())
                    .and_then(|raw| raw.strip_prefix("Bearer ").or_else(|| raw.strip_prefix("bearer ")))
                    .unwrap_or("");
                match auth.authenticate(token).await {
                    Ok(ctx) => {
                        req.extensions_mut().insert(ctx);
                        next.run(req).await
                    }
                    Err(_) => {
                        (axum::http::StatusCode::UNAUTHORIZED,
                         axum::Json(serde_json::json!({
                             "success": false,
                             "error": "unauthorized",
                             "message": "Authentication required"
                         }))
                        ).into_response()
                    }
                }
            }
        }))
}

/// Query parameters of the nested subject-history route.
#[derive(serde::Deserialize)]
pub struct JournalLineHistoryQuery {
    /// Reconstruct the row image at this instant instead of listing the trail.
    pub as_of: Option<chrono::DateTime<chrono::Utc>>,
}

/// The subject's audit history (ADR-0025 read surface): one entry per
/// captured change, newest first, positions numbered from the oldest by
/// (occurred_at, txid). `?as_of=` walks the trail forward from the
/// anchoring INSERT applying each diff's `to` values, so the row image at
/// any instant is reconstructible from the trail alone. Deleted subjects
/// still resolve history: the trail outlives the row (no FK, by contract).
pub async fn journal_line_history(
    axum::extract::State(pool): axum::extract::State<sqlx::PgPool>,
    axum::extract::Path(id): axum::extract::Path<uuid::Uuid>,
    axum::extract::Query(q): axum::extract::Query<JournalLineHistoryQuery>,
) -> axum::response::Response {
    use axum::http::StatusCode;
    use axum::response::IntoResponse;
    use serde_json::json;
    use sqlx::Row;
    let subject_id = id.to_string();
    let mut conn = match pool.acquire().await {
        Ok(c) => c,
        Err(e) => {
            return (
                StatusCode::SERVICE_UNAVAILABLE,
                axum::Json(json!({
                    "error": "history_pool_unavailable",
                    "message": e.to_string(),
                })),
            )
                .into_response()
        }
    };
    // Trail reads fence like business reads (ADR-0029 decorator): relay the
    // ambient org scope onto this self-opened connection.
    if let Some(scope) = backbone_orm::org_scope::current_org_scope() {
        if let Err(e) = backbone_orm::org_scope::bind_org_scope_on(&mut conn, &scope).await {
            return (
                StatusCode::INTERNAL_SERVER_ERROR,
                axum::Json(json!({
                    "error": "history_scope_bind",
                    "message": e.to_string(),
                })),
            )
                .into_response()
        }
    }
    const SUBJECT_TYPE: &str = "accounting.journal_lines";
    match q.as_of {
        None => {
            let rows = match sqlx::query("SELECT action, actor, changed, reason, occurred_at, txid, ROW_NUMBER() OVER (ORDER BY occurred_at, txid) AS position, COUNT(*) OVER () AS total FROM auditlog.audit_trails WHERE subject_type = $1 AND subject_id = $2 ORDER BY occurred_at DESC, txid DESC")
                .bind(SUBJECT_TYPE)
                .bind(&subject_id)
                .fetch_all(&mut *conn)
                .await
            {
                Ok(r) => r,
                Err(e) => {
                    return (
                        StatusCode::INTERNAL_SERVER_ERROR,
                        axum::Json(json!({
                            "error": "history_read",
                            "message": e.to_string(),
                        })),
                    )
                        .into_response()
                }
            };
            let total: i64 = rows.first().map(|r| r.get("total")).unwrap_or(0);
            let entries: Vec<serde_json::Value> = rows
                .iter()
                .map(|r| {
                    json!({
                        "position": r.get::<i64, _>("position"),
                        "action": r.get::<String, _>("action"),
                        "actor": r.get::<String, _>("actor"),
                        "changed": r.get::<serde_json::Value, _>("changed"),
                        "reason": r.get::<Option<String>, _>("reason"),
                        "occurred_at": r.get::<chrono::DateTime<chrono::Utc>, _>("occurred_at"),
                        "txid": r.get::<String, _>("txid"),
                    })
                })
                .collect();
            (
                StatusCode::OK,
                axum::Json(json!({
                    "subject_type": SUBJECT_TYPE,
                    "subject_id": subject_id,
                    "total": total,
                    "entries": entries,
                })),
            )
                .into_response()
        }
        Some(as_of) => {
            let rows = match sqlx::query("SELECT action, changed, occurred_at FROM auditlog.audit_trails WHERE subject_type = $1 AND subject_id = $2 AND occurred_at <= $3 ORDER BY occurred_at ASC, txid ASC")
                .bind(SUBJECT_TYPE)
                .bind(&subject_id)
                .bind(as_of)
                .fetch_all(&mut *conn)
                .await
            {
                Ok(r) => r,
                Err(e) => {
                    return (
                        StatusCode::INTERNAL_SERVER_ERROR,
                        axum::Json(json!({
                            "error": "history_read",
                            "message": e.to_string(),
                        })),
                    )
                        .into_response()
                }
            };
            if rows.is_empty() {
                return (
                    StatusCode::NOT_FOUND,
                    axum::Json(json!({
                        "error": "history_before_subject",
                        "message": "as_of precedes the subject's first captured event",
                    })),
                )
                    .into_response();
            }
            let mut image = serde_json::Map::new();
            let mut deleted_at: Option<chrono::DateTime<chrono::Utc>> = None;
            for r in &rows {
                let action: String = r.get("action");
                let changed: serde_json::Value = r.get("changed");
                if action == "delete" {
                    image.clear();
                    deleted_at = Some(r.get("occurred_at"));
                    continue;
                }
                deleted_at = None;
                if let Some(fields) = changed.as_object() {
                    for (field, diff) in fields {
                        if let Some(to) = diff.get("to") {
                            image.insert(field.clone(), to.clone());
                        }
                    }
                }
            }
            if let Some(at) = deleted_at {
                return (
                    StatusCode::NOT_FOUND,
                    axum::Json(json!({
                        "error": "subject_deleted_before_as_of",
                        "deleted_at": at,
                    })),
                )
                    .into_response();
            }
            (
                StatusCode::OK,
                axum::Json(json!({
                    "as_of": as_of,
                    "image": serde_json::Value::Object(image),
                })),
            )
                .into_response()
        }
    }
}

/// The nested history route, merged next to the model's CRUD router by the
/// module's route composer (the pool there is the tenant-resolved one).
pub fn create_journal_line_history_route(pool: sqlx::PgPool) -> axum::Router {
    axum::Router::new()
        .route("/journal_lines/:id/history", axum::routing::get(journal_line_history))
        .with_state(pool)
}