Bootstrap

// src/bootstrap.rs
use kit::{bind, global_middleware, singleton, App, DB};
use crate::middleware;

pub async fn register() {
    // Initialize database connection
    DB::init().await.expect("Failed to connect to database");

    // Global middleware (runs on every request)
    global_middleware!(middleware::LoggingMiddleware);

    // Register services that need runtime configuration
    // bind!(dyn CacheStore, RedisCache::new(&redis_url));
}

// src/main.rs
#[tokio::main]
async fn main() {
    // 1. Initialize framework configuration (loads .env files)
    Config::init(std::path::Path::new("."));

    // 2. Register application configs
    config::register_all();

    // 3. Register services and global middleware
    bootstrap::register().await;

    // 4. Register routes
    let router = routes::register();

    // 5. Start server
    Server::from_config(router)
        .run()
        .await
        .expect("Failed to start server");
}

use kit::DB;

pub async fn register() {
    DB::init().await.expect("Failed to connect to database");
}

use kit::global_middleware;
use crate::middleware;

pub async fn register() {
    // Middleware runs in registration order
    global_middleware!(middleware::LoggingMiddleware);
    global_middleware!(middleware::CorsMiddleware);
    global_middleware!(middleware::SecurityHeadersMiddleware);
}

use kit::{singleton, bind};

pub async fn register() {
    // Services configured from environment
    let redis_url = std::env::var("REDIS_URL").unwrap_or_default();
    bind!(dyn CacheStore, RedisCache::new(&redis_url));

    // Services with complex initialization
    let smtp_config = SmtpConfig::from_env();
    singleton!(EmailService::new(smtp_config));

    // External API clients
    let api_key = std::env::var("STRIPE_API_KEY").expect("STRIPE_API_KEY required");
    singleton!(StripeClient::new(&api_key));
}

use kit::bind;
use std::sync::Arc;

pub async fn register() {
    // Bind trait to implementation
    bind!(dyn PaymentGateway, StripeGateway::new());
    bind!(dyn EmailSender, SmtpEmailSender::new());
    bind!(dyn CacheStore, RedisCache::new());
}

// Simple services without runtime configuration
#[injectable]
pub struct UserService;

// Services with injected dependencies
#[injectable]
pub struct OrderService {
    #[inject]
    user_service: UserService,
}

pub async fn register() {
    // Database connections
    DB::init().await.expect("Database connection failed");

    // Services configured from environment
    let api_key = std::env::var("API_KEY")?;
    singleton!(ExternalApiClient::new(&api_key));

    // Conditional service registration
    if cfg!(debug_assertions) {
        singleton!(MockPaymentGateway::new());
    } else {
        singleton!(RealPaymentGateway::new());
    }
}

//! Application Bootstrap
//!
//! Register global middleware and services that need runtime configuration.

use kit::{bind, global_middleware, singleton, App, DB};
use crate::middleware;
use std::sync::Arc;

pub async fn register() {
    // ═══════════════════════════════════════════════════════
    // Database
    // ═══════════════════════════════════════════════════════
    DB::init().await.expect("Failed to connect to database");

    // ═══════════════════════════════════════════════════════
    // Global Middleware (runs on every request, in order)
    // ═══════════════════════════════════════════════════════
    global_middleware!(middleware::LoggingMiddleware);
    global_middleware!(middleware::CorsMiddleware);

    // ═══════════════════════════════════════════════════════
    // Cache
    // ═══════════════════════════════════════════════════════
    let redis_url = std::env::var("REDIS_URL")
        .unwrap_or_else(|_| "redis://localhost:6379".to_string());
    bind!(dyn CacheStore, RedisCache::new(&redis_url));

    // ═══════════════════════════════════════════════════════
    // Email
    // ═══════════════════════════════════════════════════════
    let smtp_host = std::env::var("SMTP_HOST").unwrap_or_default();
    let smtp_port = std::env::var("SMTP_PORT")
        .unwrap_or_else(|_| "587".to_string())
        .parse()
        .unwrap_or(587);
    singleton!(EmailService::new(&smtp_host, smtp_port));

    // ═══════════════════════════════════════════════════════
    // External Services
    // ═══════════════════════════════════════════════════════
    if let Ok(stripe_key) = std::env::var("STRIPE_SECRET_KEY") {
        singleton!(StripeClient::new(&stripe_key));
    }
}