backbone-catalog 0.7.0

//! Catalog Module Routes
//!
//! Generated by metaphor-schema. Do not edit manually.
//!
//! This module provides route composition with dual pattern support:
//! - Stateless routes: `create_stateless_routes()` -> `Router<()>`
//! - Stateful routes: `create_stateful_routes()` -> `Router<AppState>`

use axum::Router;
use std::sync::Arc;

// Import handlers
use crate::presentation::http::{
    create_attribute_routes,
    create_attribute_read_routes,
    create_attribute_value_routes,
    create_attribute_value_read_routes,
    create_brand_routes,
    create_brand_read_routes,
    create_item_routes,
    create_item_read_routes,
    create_item_group_routes,
    create_item_group_read_routes,
    create_item_variant_routes,
    create_item_variant_read_routes,
    create_uom_routes,
    create_uom_read_routes,
    create_uom_conversion_routes,
    create_uom_conversion_read_routes
};

// Import AppState for stateful routes
use crate::handlers::AppState;

// ============================================================
// PATTERN 1: STATELESS ROUTES
// ============================================================

/// Create stateless routes for the Catalog module.
///
/// These routes don't require shared state and are simpler to use.
/// Use this when you only need standard CRUD operations.
///
/// # Example
///
/// ```ignore
/// let module = CatalogModule::builder().with_database(pool).build()?;
/// let routes = create_stateless_routes(&module);
/// let app = Router::new().merge(routes);
/// ```
#[cfg(any(test, feature = "unguarded"))]
pub fn create_stateless_routes(module: &crate::CatalogModule) -> Router<()> {
    Router::new()
        .merge(create_attribute_routes(module.attribute_service.clone()))
        .merge(create_attribute_value_routes(module.attribute_value_service.clone()))
        .merge(create_brand_routes(module.brand_service.clone()))
        .merge(create_item_routes(module.item_service.clone()))
        .merge(create_item_group_routes(module.item_group_service.clone()))
        .merge(create_item_variant_routes(module.item_variant_service.clone()))
        .merge(create_uom_routes(module.uom_service.clone()))
        .merge(create_uom_conversion_routes(module.uom_conversion_service.clone()))
}

/// Read-only routes for the Catalog module — every entity mounted READ-ONLY (the guarded base).
///
/// The generic `create_stateless_routes` exposes full mutable CRUD with no domain
/// validation; this exposes only reads, so generic mutation can't bypass a write
/// service's invariants. Extend it: `create_readonly_catalog_routes(m).merge(my_validated_writes)`.
pub fn create_readonly_catalog_routes(module: &crate::CatalogModule) -> Router<()> {
    Router::new()
        .merge(create_attribute_read_routes(module.attribute_service.clone()))
        .merge(create_attribute_value_read_routes(module.attribute_value_service.clone()))
        .merge(create_brand_read_routes(module.brand_service.clone()))
        .merge(create_item_read_routes(module.item_service.clone()))
        .merge(create_item_group_read_routes(module.item_group_service.clone()))
        .merge(create_item_variant_read_routes(module.item_variant_service.clone()))
        .merge(create_uom_read_routes(module.uom_service.clone()))
        .merge(create_uom_conversion_read_routes(module.uom_conversion_service.clone()))
}

/// Get all routes (stateless) for the Catalog module.
///
/// This is a convenience function that wraps routes with API versioning.
#[cfg(any(test, feature = "unguarded"))]
pub fn get_routes(module: &crate::CatalogModule) -> Router<()> {
    Router::new()
        .nest("/api/v1", create_stateless_routes(module))
}

// ============================================================
// PATTERN 2: STATEFUL ROUTES (WITH APPSTATE)
// ============================================================

/// Create stateful routes for the Catalog module.
///
/// These routes require AppState and support custom handlers
/// that need access to services via dependency injection.
///
/// # Example
///
/// ```ignore
/// let module = CatalogModule::builder().with_database(pool).build()?;
/// let state = AppState::from_module(&module);
/// let routes = create_stateful_routes();
/// let app = Router::new().merge(routes).with_state(state);
/// ```
pub fn create_stateful_routes() -> Router<AppState> {
    Router::new()
        // Add custom handlers here that need AppState
        // .route("/custom", get(custom_handler))
}

/// Create combined routes (stateless CRUD + stateful custom handlers).
///
/// This merges both stateless CRUD routes and stateful custom routes.
#[cfg(any(test, feature = "unguarded"))]
pub fn create_combined_routes(module: &crate::CatalogModule) -> Router<AppState> {
    // First create stateless routes
    let crud_routes: Router<()> = create_stateless_routes(module);

    // Convert to stateful by adding state requirement
    // Note: The CRUD routes don't actually use the state,
    // but this allows them to be merged with stateful routes.
    let crud_routes_stateful: Router<AppState> = crud_routes.with_state(()).into();

    // Merge with stateful routes
    Router::new()
        .merge(crud_routes_stateful)
        .merge(create_stateful_routes())
}

/// Get all routes (stateful) for the Catalog module.
///
/// This is a convenience function that wraps routes with API versioning.
#[cfg(any(test, feature = "unguarded"))]
pub fn get_routes_with_state(module: &crate::CatalogModule) -> Router<AppState> {
    Router::new()
        .nest("/api/v1", create_combined_routes(module))
}

// ============================================================
// CUSTOM HANDLERS
// ============================================================

// <<< CUSTOM HANDLERS START >>>
// Add custom route handlers here
// Example:
//
// use axum::extract::State;
// use axum::response::IntoResponse;
//
// pub async fn custom_handler(
//     State(state): State<AppState>,
// ) -> impl IntoResponse {
//     // Use state.user_service, etc.
//     "Custom response"
// }
// <<< CUSTOM HANDLERS END >>>