forte-cli 0.5.0

mod cli;
mod server;
mod sqld;
mod tools;

use anyhow::Result;
use clap::Parser;
use cli::{
    AddCommands, AdminCommands, Cli, CloudflareCommands, Commands, DomainCommands, EnvCommands,
};

fn main() -> Result<()> {
    let rt = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()?;
    let local = tokio::task::LocalSet::new();
    rt.block_on(local.run_until(async_main()))
}

async fn async_main() -> Result<()> {
    let _ = rustls::crypto::aws_lc_rs::default_provider().install_default();
    let cli = Cli::parse();

    match cli.command {
        Commands::Dev { project, port } => {
            let options = cli::dev::DevOptions {
                project_dir: project.unwrap_or_else(|| ".".into()),
                port,
            };
            cli::dev::run(options).await?;
        }

        Commands::Init { name, dev } => {
            cli::init::run(&name, dev)?;
        }

        Commands::Login { token } => {
            cli::login::run(token).await?;
        }

        Commands::Add { command } => match command {
            AddCommands::Page { path } => {
                cli::add::add_page(&path)?;
            }
            AddCommands::Action { path } => {
                cli::add::add_action(&path)?;
            }
        },

        Commands::Build { project } => {
            let project_dir = project.unwrap_or_else(|| ".".into());
            cli::build::run_build(cli::build::BuildOptions {
                project_dir,
                static_base_url: None,
            })
            .await?;
        }

        Commands::Deploy { project, name } => {
            let project_dir = project.unwrap_or_else(|| ".".into());
            cli::deploy::run(project_dir, name).await?;
        }

        Commands::Destroy { yes } => {
            cli::destroy::run(".".into(), yes).await?;
        }

        Commands::Open { project, print } => {
            let project_dir = project.unwrap_or_else(|| ".".into());
            cli::open::run(project_dir, print).await?;
        }

        Commands::Purge { keys, project } => {
            let project_dir = project.unwrap_or_else(|| ".".into());
            cli::purge::run(keys, project_dir).await?;
        }

        Commands::Admin { command } => match command {
            AdminCommands::Run {
                task,
                project,
                input_file,
                input,
                timeout_seconds,
            } => {
                let project_dir = project.unwrap_or_else(|| ".".into());
                cli::admin::run(task, project_dir, input_file, input, timeout_seconds).await?;
            }
            AdminCommands::RunLocal {
                task,
                port,
                input_file,
                input,
                timeout_seconds,
            } => {
                cli::admin::run_local(task, port, input_file, input, timeout_seconds).await?;
            }
        },

        Commands::Cloudflare { command } => match command {
            CloudflareCommands::Connect {
                account_id,
                zone_id,
                api_token,
                zone_name,
                worker_access_key_id,
                worker_secret,
                frontend_asset_access_key_id,
                frontend_asset_secret,
                purge_token,
                project,
            } => {
                let project_dir = project.unwrap_or_else(|| ".".into());
                cli::cloudflare::connect(
                    project_dir,
                    account_id,
                    zone_id,
                    api_token,
                    zone_name,
                    worker_access_key_id,
                    worker_secret,
                    frontend_asset_access_key_id,
                    frontend_asset_secret,
                    purge_token,
                )
                .await?;
            }
            CloudflareCommands::Provision {
                account_id,
                zone_id,
                api_token,
                project,
            } => {
                let project_dir = project.unwrap_or_else(|| ".".into());
                cli::cloudflare::provision(project_dir, account_id, zone_id, api_token).await?;
            }
            CloudflareCommands::Status { project } => {
                let project_dir = project.unwrap_or_else(|| ".".into());
                cli::cloudflare::status(project_dir).await?;
            }
        },
        Commands::Domain { command } => match command {
            DomainCommands::Add {
                domain,
                account_id,
                zone_id,
                api_token,
                mint_signing_token,
                project,
            } => {
                let project_dir = project.unwrap_or_else(|| ".".into());
                cli::domain::add(
                    project_dir,
                    domain,
                    account_id,
                    zone_id,
                    api_token,
                    mint_signing_token,
                )
                .await?;
            }
            DomainCommands::Remove { project } => {
                let project_dir = project.unwrap_or_else(|| ".".into());
                cli::domain::remove(project_dir).await?;
            }
            DomainCommands::Status { project } => {
                let project_dir = project.unwrap_or_else(|| ".".into());
                cli::domain::status(project_dir).await?;
            }
        },

        Commands::Env { command } => match command {
            EnvCommands::Set {
                key,
                value,
                secret,
                project,
            } => {
                let project_dir = project.unwrap_or_else(|| ".".into());
                cli::env::set(&project_dir, key, value, secret).await?;
            }
            EnvCommands::Migrate { project } => {
                let project_dir = project.unwrap_or_else(|| ".".into());
                cli::env::migrate(&project_dir)?;
            }
        },
    }

    Ok(())
}