Configuration¶

use axum::response::Json;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use spikard::{get, App, ServerConfig};

#[derive(Serialize, Deserialize, JsonSchema)]
struct HealthResponse {
    status: String,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = ServerConfig::builder()
        .host("0.0.0.0")
        .port(8080)
        .workers(4)
        .request_timeout_secs(60)
        .max_body_size(5 * 1024 * 1024)  // 5MB
        .build();

    let mut app = App::with_config(config);

    app.route(get("/health"), |_ctx| async move {
        Ok(Json(HealthResponse { status: "ok".into() }).into())
    })?;

    app.run().await?;
    Ok(())
}

use spikard::{App, ServerConfig};
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Load from .env file if present
    dotenv::dotenv().ok();

    let config = ServerConfig::builder()
        .host(env::var("SPIKARD_HOST").unwrap_or_else(|_| "127.0.0.1".into()))
        .port(
            env::var("SPIKARD_PORT")
                .ok()
                .and_then(|p| p.parse().ok())
                .unwrap_or(8000),
        )
        .workers(
            env::var("SPIKARD_WORKERS")
                .ok()
                .and_then(|w| w.parse().ok())
                .unwrap_or(1),
        )
        .request_timeout_secs(
            env::var("SPIKARD_TIMEOUT")
                .ok()
                .and_then(|t| t.parse().ok())
                .unwrap_or(30),
        )
        .build();

    let app = App::with_config(config);

    // Keep secrets in env
    let api_key = env::var("API_KEY").ok();
    let db_url = env::var("DATABASE_URL").ok();

    app.run().await?;
    Ok(())
}

use spikard::{
    App, CompressionConfig, OpenApiConfig, RateLimitConfig, ServerConfig,
};
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Production logging setup
    tracing_subscriber::registry()
        .with(tracing_subscriber::fmt::layer().json())
        .with(tracing_subscriber::EnvFilter::from_default_env())
        .init();

    // Panic handling for production
    std::panic::set_hook(Box::new(|info| {
        tracing::error!("Panic occurred: {:?}", info);
    }));

    let config = ServerConfig::builder()
        .host("0.0.0.0")
        .port(8080)
        .workers(4)
        .request_timeout_secs(60)
        .max_body_size(10 * 1024 * 1024)

        // High-quality compression
        .compression(
            CompressionConfig::builder()
                .gzip(true)
                .brotli(true)
                .min_size(1024)
                .quality(6)
                .build(),
        )

        // Protect against abuse
        .rate_limit(
            RateLimitConfig::builder()
                .per_second(100)
                .burst(200)
                .ip_based(true)
                .build(),
        )

        // Auto-generated docs
        .openapi(
            OpenApiConfig::builder()
                .enabled(true)
                .title("Production API")
                .version("1.0.0")
                .build(),
        )

        // Graceful shutdown
        .graceful_shutdown(true)
        .shutdown_timeout_secs(30)
        .build();

    let app = App::with_config(config);
    app.run().await?;
    Ok(())
}