mockd-http 0.1.0

//! Mockd command-line interface.
//!
//! Usage:
//!
//! ```text
//! mockd serve <config.yaml>      Start the mock server.
//! mockd validate <config.yaml>   Check that the config parses and compiles.
//! ```

use std::path::PathBuf;
use std::process::ExitCode;

use clap::{Parser, Subcommand};

use mockd::config::Config;
use mockd::server::Server;

/// A lightweight standalone mock HTTP server driven by a YAML config.
#[derive(Debug, Parser)]
#[command(name = "mockd", version, about, long_about = None)]
struct Cli {
    #[command(subcommand)]
    command: Command,
}

#[derive(Debug, Subcommand)]
enum Command {
    /// Start the mock server using the given configuration file.
    Serve {
        /// Path to the YAML configuration file.
        config: PathBuf,

        /// Enable permissive CORS support. Adds `Access-Control-Allow-Origin: *`
        /// to every response and answers `OPTIONS` preflight requests with
        /// `204 No Content` without consulting the routes.
        #[arg(long)]
        cors: bool,
    },
    /// Parse and compile the configuration file without starting a server.
    ///
    /// Exits with a non-zero status if the configuration is invalid.
    Validate {
        /// Path to the YAML configuration file.
        config: PathBuf,
    },
}

fn main() -> ExitCode {
    // Initialize logging from `RUST_LOG`, defaulting to `mockd=info` so that
    // every handled request is logged unless the user asks for quieter output.
    let env_filter = tracing_subscriber::EnvFilter::try_from_default_env()
        .unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("mockd=info"));
    tracing_subscriber::fmt().with_env_filter(env_filter).init();

    let cli = Cli::parse();
    match run(cli) {
        Ok(()) => ExitCode::SUCCESS,
        Err(err) => {
            tracing::error!("{err:#}");
            ExitCode::FAILURE
        }
    }
}

fn run(cli: Cli) -> anyhow::Result<()> {
    match cli.command {
        Command::Serve { config, cors } => {
            let cfg = Config::from_file(&config)?;
            let server = Server::from_config(cfg)?.with_cors(cors);
            let runtime = tokio::runtime::Builder::new_multi_thread()
                .enable_all()
                .build()?;
            runtime.block_on(server.serve())?;
        }
        Command::Validate { config } => {
            let cfg = Config::from_file(&config)?;
            // Compile the routes to catch path-pattern errors too.
            let server = Server::from_config(cfg)?;
            tracing::info!(
                "config is valid: {} route(s) registered",
                server.route_count()
            );
        }
    }
    Ok(())
}