bloom-web 0.1.4

// Comprehensive test to verify all crates are accessible through bloom_web
// This file tests every dependency that users might need

// Test 1: Basic framework imports
use bloom_web::prelude::*;

// Test 2: Direct crate access through bloom_web (not prelude)
use bloom_web::{sqlx, actix_web, serde, serde_json, chrono, anyhow, utoipa, tokio, inventory};

// Test 3: Specific types that users commonly need
use bloom_web::actix_web::web::{Path, Data, Json};
use bloom_web::actix_web::{HttpResponse, HttpRequest, middleware};
use bloom_web::sqlx::{MySqlPool, PgPool, SqlitePool, FromRow, Row};
use bloom_web::serde::{Serialize, Deserialize};
use bloom_web::chrono::{DateTime, Utc};
use bloom_web::anyhow::{Result, Error};
use bloom_web::utoipa::{OpenApi, ToSchema};

#[derive(Entity, Debug, Clone, Serialize, Deserialize, FromRow)]
#[table("comprehensive_test")]
pub struct ComprehensiveTest {
    #[id]
    pub id: i32,
    pub name: String,
    pub created_at: DateTime<Utc>,
}

#[repository(ComprehensiveTest)]
pub struct ComprehensiveTestRepository;

#[get_mapping("/comprehensive/{id}")]
pub async fn comprehensive_test(
    path: Path<i64>,
    pool: Data<MySqlPool>,
    _req: HttpRequest
) -> HttpResponse {
    match ComprehensiveTestRepository::find_by_id::<ComprehensiveTest>(pool.get_ref(), path.into_inner()).await {
        Ok(Some(item)) => HttpResponse::Ok().json(item),
        Ok(None) => HttpResponse::NotFound().finish(),
        Err(_) => HttpResponse::InternalServerError().finish(),
    }
}

#[post_mapping("/comprehensive")]
pub async fn create_comprehensive_test(
    data: Json<ComprehensiveTest>,
    pool: Data<MySqlPool>
) -> HttpResponse {
    match data.insert(pool.get_ref()).await {
        Ok(_) => HttpResponse::Created().finish(),
        Err(_) => HttpResponse::InternalServerError().finish(),
    }
}

fn test_all_dependencies() -> Result<()> {
    // Test sqlx types
    let _pool: Option<MySqlPool> = None;
    let _pg_pool: Option<PgPool> = None;
    let _sqlite_pool: Option<SqlitePool> = None;

    // Test serde functionality
    let test_data = ComprehensiveTest {
        id: 1,
        name: "test".to_string(),
        created_at: Utc::now(),
    };
    let _json = serde_json::to_string(&test_data)?;

    // Test chrono functionality
    let _now = Utc::now();

    // Test anyhow functionality
    let _result: Result<()> = Ok(());

    println!("All dependency tests passed successfully!");
    Ok(())
}

fn main() {
    match test_all_dependencies() {
        Ok(_) => println!("✅ All bloom_web dependencies are properly accessible!"),
        Err(e) => println!("❌ Dependency test failed: {}", e),
    }
}