ordinary 0.11.0

// Copyright (C) 2026 The Ordinary Authors.
//
// SPDX-License-Identifier: BSD-3-Clause

pub mod assets;
pub mod database;
pub mod functions;
pub mod secrets;

use crate::cmds::accounts::get_current_account;
use crate::cmds::logs::{Logs, Sync, print_logs_metadata_table};
use crate::{GENERATOR, USER_AGENT};
use anyhow::bail;
use assets::Assets;
use clap::Subcommand;
use clap::builder::PossibleValue;
use database::Database;
use functions::Functions;
use ordinary_api::client::OrdinaryApiClient;
use ordinary_build::traverse;
use ordinary_config::OrdinaryConfig;
use ordinaryd::{AppApi, GlobalArgs};
use secrets::Secrets;
use std::path::Path;
use tracing::instrument;

#[derive(Subcommand, Debug)]
pub enum App {
    /// create a new Ordinary project
    #[clap(visible_aliases(["create", "init"]))]
    New {
        /// project domain
        domain: String,
        /// project path
        #[arg(long, default_value = ".")]
        path: String,
    },
    /// build your Ordinary app
    ///
    /// Note: will load environment variables from `.env`
    Build {
        /// build project without checking the cache
        #[arg(short, long, default_value_t = false)]
        force: bool,
    },
    /// start the app, locally
    #[clap(visible_aliases(["run", "preview"]))]
    Start {
        #[command(flatten)]
        app_api: AppApi,

        #[command(flatten)]
        global_args: GlobalArgs,

        /// disables these defaults set for development:
        /// `--stdio-logs`
        /// `--stdio-logs-fmt concise`
        /// `--insecure`
        /// `--insecure-cookies`
        #[arg(short, long, default_value_t = false)]
        disable_defaults: bool,
    },
    /// combines `build`, `deploy`, `assets write`, and `functions upload`
    Publish {
        /// overrides if mode=production. does nothing if mode is localhost or staging
        ///
        /// useful for when you're validating that your DNS is configured properly, and you
        /// want to avoid the Let's Encrypt rate limit for production mode <https://letsencrypt.org/docs/rate-limits/>
        #[arg(short, long, default_value_t = false)]
        tls_staging: bool,

        /// if `true`, will not seed the app database on publish
        #[arg(long, default_value_t = false)]
        no_seed: bool,
    },
    /// deploy a changes to ordinary.json
    Deploy {
        /// whether the result of the operation should be
        /// printed to stdout formatted as JSON
        #[arg(short, long, default_value_t = false)]
        json_to_stdout: bool,

        /// overrides if mode=production. does nothing if mode is localhost or staging
        ///
        /// useful for when you're validating that your DNS is configured properly, and you
        /// want to avoid the Let's Encrypt rate limit for production mode <https://letsencrypt.org/docs/rate-limits/>
        #[arg(short, long, default_value_t = false)]
        tls_staging: bool,
    },
    /// push a configuration change which will
    /// modify the shape of your data stores
    ///
    /// (i.e. a structural change to model or content definitions)
    Migrate,
    /// kill a running instance of the application
    Kill,
    /// restart a deployed/running instance of the application on `ordinaryd`
    Restart {
        /// whether the result of the operation should be
        /// printed to stdout formatted as JSON
        #[arg(short, long, default_value_t = false)]
        json_to_stdout: bool,

        /// overrides if mode=production. does nothing if mode is localhost or staging
        ///
        /// useful for when you're validating that your DNS is configured properly, and you
        /// want to avoid the Let's Encrypt rate limit for production mode <https://letsencrypt.org/docs/rate-limits/>
        #[arg(short, long, default_value_t = false)]
        tls_staging: bool,
    },
    /// fully erase all content of the application from the host
    Erase,
    /// query application logs
    Logs {
        #[command(subcommand)]
        logs: Logs,
    },
    /// manage assets in your Ordinary project
    Assets {
        #[command(subcommand)]
        assets: Assets,
    },
    /// manage application accounts
    #[clap(visible_aliases(["account", "accts", "acct"]))]
    Accounts {
        #[command(subcommand)]
        accounts: Accounts,
    },
    /// manage functions on your Ordinary app
    #[clap(visible_aliases(["fns", "fn", "function"]))]
    Functions {
        #[command(subcommand)]
        functions: Functions,
    },
    /// manage database models in your Ordinary app
    #[clap(visible_aliases(["db"]))]
    Database {
        #[command(subcommand)]
        database: Database,
    },
    /// manage secrets in your Ordinary application
    Secrets {
        #[command(subcommand)]
        secrets: Secrets,
    },
    /// view and validate the app config
    Config {
        #[command(subcommand)]
        config: Config,
    },
    /// list all HTTP routes
    Routes,
}

#[derive(Subcommand, Debug)]
pub enum Accounts {
    /// list application accounts
    #[clap(visible_aliases(["ls"]))]
    List,
}

#[derive(Subcommand, Debug)]
pub enum Config {
    /// view the config that will be produced and used
    /// by operations that depend on its assembled state.
    View {
        #[arg(short, long, default_value = "build")]
        r#for: For,
    },
    /// validate the existing config in an assembled state.
    Validate {
        #[arg(short, long, default_value = "build")]
        r#for: For,
    },
}

#[derive(Clone, Debug, PartialOrd, PartialEq)]
pub enum For {
    Build,
    Deploy,
}

impl clap::ValueEnum for For {
    fn value_variants<'a>() -> &'a [Self] {
        &[Self::Build, Self::Deploy]
    }

    fn to_possible_value(&self) -> Option<PossibleValue> {
        match self {
            Self::Build => Some(PossibleValue::new("build")),
            Self::Deploy => Some(PossibleValue::new("deploy")),
        }
    }
}

impl App {
    #[allow(clippy::missing_panics_doc, clippy::too_many_lines)]
    #[instrument(skip_all, name = "app")]
    pub async fn handle(
        &self,
        api_domain: Option<&str>,
        accept_invalid_certs: bool,
        project: &str,
        insecure: bool,
    ) -> anyhow::Result<()> {
        let account = get_current_account(insecure)?;
        let client = OrdinaryApiClient::new(
            &account.host,
            &account.name,
            api_domain,
            accept_invalid_certs,
            crate::USER_AGENT,
            false,
        )?;

        match self {
            Self::New { path, domain } => ordinary_modify::project::new(path, domain)?,
            Self::Build {
                force: ignore_cache,
            } => {
                let env_file = Path::new(project).join(".env");
                if env_file.exists() {
                    dotenvy::from_path(env_file)?;
                }

                ordinary_build::build(project, *ignore_cache, "ordinary")?;
            }
            Self::Publish {
                tls_staging,
                no_seed,
            } => {
                let env_file = Path::new(project).join(".env");
                if env_file.exists() {
                    dotenvy::from_path(env_file)?;
                }

                ordinary_build::build(project, true, GENERATOR)?;

                let account = get_current_account(insecure)?;
                let client = OrdinaryApiClient::new(
                    &account.host,
                    &account.name,
                    api_domain,
                    accept_invalid_certs,
                    USER_AGENT,
                    true,
                )?;

                let config = OrdinaryConfig::get(project, true)?;

                client.app_deploy(project, *tls_staging).await?;

                if !no_seed {
                    client.database_items_seed(project).await?;
                }

                if config.assets.is_some() {
                    client.assets_write_all(project).await?;
                }

                if config.functions.is_some() {
                    client.functions_upload_all(project).await?;
                }
            }
            Self::Deploy {
                json_to_stdout,
                tls_staging,
            } => {
                let ports_res = client.app_deploy(project, *tls_staging).await?;
                tracing::info!("app deployed");

                if *json_to_stdout {
                    println!("{}", serde_json::to_string(&ports_res)?);
                }
            }
            Self::Migrate => {
                println!("todo: migrate");
            }
            // Self::Bridge { remote } => {
            //     tracing::info!("todo: bridge {project} to {remote}");
            // }
            Self::Kill => {
                client.app_kill(project).await?;
            }
            Self::Restart {
                json_to_stdout,
                tls_staging,
            } => {
                let ports_res = client.app_restart(project, *tls_staging).await?;
                tracing::info!("app restarted");

                if *json_to_stdout {
                    println!("{}", serde_json::to_string(&ports_res)?);
                }
            }
            Self::Erase => {
                client.app_erase(project).await?;
            }
            Self::Logs { logs } => match logs {
                Logs::Query {
                    query,
                    json_columns,
                    sync,
                } => {
                    if sync == &Some(true) {
                        client.app_logs_sync(project, None, None).await?;
                    }

                    let res = client.app_logs_query(project, query, json_columns.as_ref())?;
                    print!("{res}");
                }
                Logs::Search {
                    format,
                    query,
                    limit,
                    sync,
                } => {
                    if sync == &Some(true) {
                        client.app_logs_sync(project, None, None).await?;
                    }

                    let res = client.app_logs_search(project, query, format.as_str(), *limit)?;

                    print!("{res}");
                }
                Logs::List => client.app_logs_file_list(project)?,
                Logs::Read { name } => {
                    if let Some(name) = name {
                        client.app_logs_file_read(project, name)?;
                    } else {
                        client.app_logs_file_read_all(project)?;
                    }
                }
                Logs::Sync { sync } => match sync {
                    Sync::Info => {
                        let remote_metadata = client.app_logs_remote_metadata(project).await?;
                        let local_metadata = client.app_logs_local_metadata(project)?;

                        print_logs_metadata_table(remote_metadata, local_metadata);
                    }
                    Sync::All { force } => {
                        client.app_logs_sync(project, *force, None).await?;
                    }
                    Sync::File { name } => {
                        client.app_logs_sync(project, None, Some(name)).await?;
                    }
                },
            },
            Self::Accounts { accounts } => match accounts {
                Accounts::List => {
                    let res = client.app_accounts_list(project).await?;

                    print!("{res}");
                }
            },
            Self::Routes => {
                let config = OrdinaryConfig::get(project, true)?;

                println!("ROUTES\n");

                if let Some(assets) = config.assets {
                    let Some(assets_dir_path) = &assets.dir_path else {
                        bail!("assets.dir_path cannot be unset");
                    };

                    println!("assets:");

                    let base_route = assets.base_route.as_str();
                    let assets_dir = Path::new(project).join(assets_dir_path);

                    traverse(&assets_dir, &|entry| {
                        let path = entry.path();
                        let path = path.strip_prefix(&assets_dir)?;

                        if base_route == "/" {
                            println!("- GET /{}", path.display());
                        } else {
                            println!("- GET {base_route}/{}", path.display());
                        }

                        Ok(())
                    })?;

                    println!();
                }

                if let Some(http_config) = &config.http {
                    if let Some(routes) = &http_config.routes {
                        println!("functions:");

                        for http_route in routes {
                            println!("- {} {}", http_route.method, http_route.path);
                        }

                        println!();
                    }

                    if let Some(redirects) = &http_config.redirects
                        && let Some(redirects) = &redirects.route
                    {
                        println!("redirects:");

                        for redirect in redirects {
                            println!(
                                "- {} {} [ {} -> {} ]",
                                redirect.method,
                                redirect.condition,
                                redirect.rule.0,
                                redirect.rule.1
                            );
                        }

                        println!();
                    }

                    if let Some(proxies) = &http_config.proxies {
                        println!("proxies:");

                        for proxy in proxies {
                            if let Some(path) = &proxy.path {
                                println!("- ANY {path} -> {}", proxy.target);
                            } else if let Some(domain) = &proxy.domain {
                                println!("- ANY http(s)://{domain}/{{*path}} -> {}", proxy.target);
                            }
                        }

                        println!();
                    }
                }
            }
            Self::Assets { assets } => {
                assets
                    .handle(api_domain, accept_invalid_certs, project, insecure)
                    .await?;
            }
            Self::Functions { functions } => {
                functions
                    .handle(api_domain, accept_invalid_certs, project, insecure)
                    .await?;
            }
            Self::Database { database: models } => {
                models
                    .handle(api_domain, accept_invalid_certs, project, insecure)
                    .await?;
            }
            Self::Secrets { secrets } => {
                secrets
                    .handle(api_domain, accept_invalid_certs, project, insecure)
                    .await?;
            }
            Self::Config { config } => {
                let app_config = OrdinaryConfig::get(project, true)?;

                match config {
                    Config::View { r#for } => match r#for {
                        For::Build => {
                            println!("{}", serde_json::to_string_pretty(&app_config)?);
                        }
                        For::Deploy => {
                            println!("{}", serde_json::to_string_pretty(&app_config.for_send()?)?);
                        }
                    },
                    Config::Validate { r#for } => match r#for {
                        For::Build => {
                            app_config.validate()?;
                            println!("valid");
                        }
                        For::Deploy => {
                            app_config.for_send()?.validate()?;
                            println!("valid");
                        }
                    },
                }
            }
            Self::Start { .. } => unreachable!("handled in main.rs"),
        }

        Ok(())
    }
}