fundaia 0.7.2

// Some of these fields are decoded and never read. That is the point: this
// module is the wire contract written down, and a field that is dropped from
// the struct is a field the next command has to rediscover from the server's
// source. The cost of keeping them is one `#[allow]`; the cost of trimming them
// to whatever is used today is paid every time the tool grows a subcommand.
#![allow(dead_code)]

use serde::{Deserialize, Serialize};

/// The DTOs the server sends, as much of each as this tool reads.
///
/// Deliberately partial. Every struct here is `deny_unknown_fields`-free so the
/// server can grow a field without breaking an installed binary — a CLI is the
/// one client that is never redeployed alongside the API, and a strict decoder
/// would turn every additive change into a support question.

#[derive(Debug, Deserialize)]
pub struct ProjectsPage {
    pub projects: Vec<Project>,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Project {
    pub id: String,
    pub slug: String,
    pub name: String,
    #[serde(default)]
    pub environment_name: String,
    #[serde(default)]
    pub service_count: u32,
    #[serde(default)]
    pub online_count: u32,
    #[serde(default)]
    pub services: Vec<Service>,
}

#[derive(Debug, Deserialize)]
pub struct ServicesPage {
    pub services: Vec<Service>,
    #[serde(default)]
    pub edges: Vec<Edge>,
}

#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Service {
    /// The service-environment id: what every other endpoint is keyed on.
    pub id: String,
    pub service_id: String,
    pub name: String,
    pub slug: String,
    pub kind: String,
    pub state: String,
    #[serde(default)]
    pub brand: Option<String>,
    #[serde(default)]
    pub host: Option<String>,
    #[serde(default)]
    pub repo_full_name: Option<String>,
    #[serde(default)]
    pub last_deployment_number: Option<u32>,
}

#[derive(Debug, Clone, Deserialize)]
pub struct Edge {
    pub from: String,
    pub to: String,
    pub label: String,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ServiceDetail {
    pub service: ServiceIdentity,
    pub environment: ServiceEnvironment,
    #[serde(default)]
    pub domains: Vec<Domain>,
    #[serde(default)]
    pub active_deployment: Option<Deployment>,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ServiceIdentity {
    pub id: String,
    pub name: String,
    pub slug: String,
    pub kind: String,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ServiceEnvironment {
    pub id: String,
    pub state: String,
    #[serde(default)]
    pub memory_mb: u32,
    #[serde(default)]
    pub cpus: f32,
    #[serde(default)]
    pub sleep_enabled: bool,
    #[serde(default)]
    pub container_port: Option<u32>,
    #[serde(default)]
    pub health_path: Option<String>,
    #[serde(default)]
    pub adopted: bool,
}

#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Deployment {
    pub id: String,
    pub number: u32,
    pub status: String,
    pub trigger: String,
    #[serde(default)]
    pub commit_sha: Option<String>,
    #[serde(default)]
    pub commit_subject: Option<String>,
    #[serde(default)]
    pub failure_message: Option<String>,
    pub created_at: String,
    #[serde(default)]
    pub finished_at: Option<String>,
}

#[derive(Debug, Deserialize)]
pub struct DeploymentsPage {
    pub deployments: Vec<Deployment>,
}

#[derive(Debug, Deserialize)]
pub struct DeploymentAccepted {
    pub deployment: Deployment,
}

#[derive(Debug, Deserialize)]
pub struct DeploymentDetail {
    pub deployment: Deployment,
    pub pipeline: Pipeline,
}

#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Pipeline {
    pub stages: Vec<Stage>,
    #[serde(default)]
    pub current_stage_id: Option<String>,
    pub finished: bool,
    pub succeeded: bool,
}

#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Stage {
    pub id: String,
    pub label: String,
    pub state: String,
    #[serde(default)]
    pub started_at: Option<String>,
    #[serde(default)]
    pub finished_at: Option<String>,
    #[serde(default)]
    pub failure_message: Option<String>,
}

#[derive(Debug, Deserialize)]
pub struct VariablesPage {
    pub variables: Vec<Variable>,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Variable {
    pub id: String,
    pub key: String,
    pub kind: String,
    #[serde(default)]
    pub preview: Option<String>,
    #[serde(default)]
    pub write_only: bool,
    /// Set once it is sealed: no value comes back and no write is accepted.
    #[serde(default)]
    pub sealed_at: Option<String>,
}

impl Variable {
    pub fn is_sealed(&self) -> bool {
        self.sealed_at.is_some()
    }
}

#[derive(Debug, Deserialize)]
pub struct RevealedVariable {
    pub value: String,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct BackupsPage {
    #[serde(default)]
    pub schedules: Vec<String>,
    /// When the next scheduled copy is owed. Null when no schedule is on.
    #[serde(default)]
    pub next_at: Option<String>,
    /// False for a service with no volume, which has nothing to copy.
    #[serde(default)]
    pub supported: bool,
    #[serde(default)]
    pub backups: Vec<Backup>,
}

#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Backup {
    pub id: String,
    /// Null for a copy somebody asked for, which is what exempts it from retention.
    #[serde(default)]
    pub schedule: Option<String>,
    pub status: String,
    #[serde(default)]
    pub size_bytes: u64,
    #[serde(default)]
    pub locked: bool,
    #[serde(default)]
    pub failure_message: Option<String>,
    pub created_at: String,
}

#[derive(Debug, Deserialize)]
pub struct BackupTaken {
    pub backup: Backup,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct BackupSchedules {
    #[serde(default)]
    pub schedules: Vec<String>,
}

#[derive(Debug, Deserialize)]
pub struct DomainsPage {
    pub domains: Vec<Domain>,
}

#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Domain {
    pub id: String,
    pub host: String,
    pub kind: String,
    pub state: String,
    #[serde(default)]
    pub dns_instructions: Option<String>,
    /// False while the service is private: the name is kept, nothing serves it.
    ///
    /// Defaulted to true so this tool keeps working against an instance older
    /// than the switch, where every domain it can see is a serving one.
    #[serde(default = "enabled_by_default")]
    pub enabled: bool,
    pub url: String,
}

fn enabled_by_default() -> bool {
    true
}

#[derive(Debug, Deserialize)]
pub struct UsagePage {
    pub samples: Vec<UsageSample>,
}

#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct UsageSample {
    pub at: String,
    pub cpu_millicores: u32,
    pub memory_bytes: u64,
    pub memory_limit_bytes: u64,
}

#[derive(Debug, Deserialize)]
pub struct LogPage {
    pub lines: Vec<LogLine>,
}

#[derive(Debug, Clone, Deserialize)]
pub struct LogLine {
    pub sequence: u64,
    /// Absent from an older server; the column is held blank rather than
    /// shifting everything left for a log that predates it.
    #[serde(default)]
    pub at: Option<String>,
    #[serde(default)]
    pub stream: String,
    #[serde(default)]
    pub level: String,
    pub message: String,
}

/// One state change off `/api/infra/stream`.
///
/// Every field but `kind` is optional because the endpoint carries several
/// shapes down one socket — a deployment moving, a variable being written, a
/// colleague opening a field — and a client that refused to parse the ones it
/// does not draw would stop working the day a sixth is added.
#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct InfraEvent {
    pub kind: String,
    #[serde(default)]
    pub project_id: String,
    #[serde(default)]
    pub service_environment_id: Option<String>,
    #[serde(default)]
    pub deployment_id: Option<String>,
    #[serde(default)]
    pub status: Option<String>,
    #[serde(default)]
    pub state: Option<String>,
    #[serde(default)]
    pub trigger: Option<String>,
    #[serde(default)]
    pub number: Option<u32>,
    #[serde(default)]
    pub service_name: Option<String>,
    #[serde(default)]
    pub commit_sha: Option<String>,
    #[serde(default)]
    pub commit_subject: Option<String>,
    /// The variable's name on a `variable-changed`. Never its value.
    #[serde(default)]
    pub key: Option<String>,
    #[serde(default)]
    pub action: Option<String>,
}

#[derive(Debug, Deserialize)]
pub struct ConnectionCandidates {
    pub candidates: Vec<ConnectionCandidate>,
}

#[derive(Debug, Deserialize)]
pub struct ConnectionCandidate {
    pub id: String,
    pub name: String,
    pub summary: String,
}

#[derive(Debug, Deserialize)]
pub struct ConnectionMade {
    pub connection: Connection,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Connection {
    pub provider_name: String,
    pub keys: Vec<String>,
    pub summary: String,
}

#[derive(Debug, Deserialize)]
pub struct TemplatesPage {
    pub templates: Vec<Template>,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Template {
    pub key: String,
    pub display_name: String,
    pub image: String,
}

/// The three steps of letting a terminal in, as the server describes them.
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct StartedAuthorization {
    pub user_code: String,
    pub device_secret: String,
    pub verification_uri: String,
    pub verification_uri_complete: String,
    pub interval_seconds: u64,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CollectedAuthorization {
    pub status: String,
    #[serde(default)]
    pub token: Option<String>,
}

/// What the instance calls itself, so a stale binary can say so.
#[derive(Debug, Deserialize)]
pub struct ServerVersion {
    pub platform: String,
    #[serde(default)]
    pub revision: Option<String>,
    #[serde(default)]
    pub modules: std::collections::BTreeMap<String, String>,
}

#[derive(Debug, Deserialize)]
pub struct Principal {
    pub principal: Option<PrincipalIdentity>,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct PrincipalIdentity {
    pub id: String,
    pub display_name: String,
}

/// The one thing this tool sends that is not a bare field or two.
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct NewService {
    pub name: String,
    pub source_kind: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub repo_full_name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub branch: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub image: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub template_key: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kind: Option<String>,
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub connect_to: Vec<String>,
}

// ------------------------------------------------------------- workspaces

#[derive(Debug, Deserialize)]
pub struct WorkspacesPage {
    pub workspaces: Vec<Workspace>,
}

/// A place several people share, holding several projects.
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Workspace {
    pub id: String,
    pub name: String,
    pub slug: String,
    /// What the caller is in it. Null for the instance owner, who is in none.
    #[serde(default)]
    pub role: Option<String>,
}

#[derive(Debug, Deserialize)]
pub struct MembersPage {
    pub members: Vec<Member>,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Member {
    pub user_id: String,
    pub role: String,
    #[serde(default)]
    pub display_name: Option<String>,
    #[serde(default)]
    pub github_login: Option<String>,
    #[serde(default)]
    pub email: Option<String>,
}

#[derive(Debug, Deserialize)]
pub struct InvitationsPage {
    pub invitations: Vec<Invitation>,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Invitation {
    pub id: String,
    pub email: String,
    pub role: String,
    pub status: String,
}

/// What creating one answers with, link included.
///
/// The link comes back so the terminal can print it: a person running this over
/// SSH is often the same person who would otherwise have to go and find the
/// email, and delivery is the part most likely to be slow or unconfigured.
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SentInvitation {
    pub accept_url: String,
}

#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct NewInvitation {
    pub email: String,
    pub role: String,
}

// ------------------------------------------------------- settings & capacity

/// What the machine has left.
///
/// Numbers rather than a verdict: the terminal asking is usually about to
/// decide how big to make the next service.
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Capacity {
    pub total_memory_mb: u64,
    pub reserved_memory_mb: u64,
    pub committed_memory_mb: u64,
    pub available_memory_mb: u64,
    pub ports_in_use: u32,
    pub ports_total: u32,
    pub remaining_at_default_size: u32,
    pub running_low: bool,
}

/// The result of turning bucket encryption on or off.
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct EncryptionOutcome {
    pub enabled: bool,
    pub buckets: Vec<String>,
    /// Objects rewritten so what was already stored is covered too.
    pub re_encrypted: u32,
}

/// What a service answers on after publishing it, or taking it off.
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ExposureOutcome {
    pub domains: Vec<Domain>,
}

/// A PATCH of a service's settings: absent keys are left alone.
#[derive(Debug, Default, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SettingsPatch {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub memory_mb: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub replicas: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub root_directory: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub start_command: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub health_path: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub restart_policy: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sleep_enabled: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub auto_deploy: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_enabled: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cache_ttl_seconds: Option<u32>,
}

#[derive(Debug, Deserialize)]
pub struct VolumesPage {
    pub volumes: Vec<Volume>,
}

#[derive(Debug, Deserialize)]
pub struct VolumeAttached {
    pub volume: Volume,
}

/// A directory that outlives the container it is mounted into.
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Volume {
    pub id: String,
    pub name: String,
    pub mount_path: String,
    /// False until the next deployment picks it up, which is why attaching says
    /// so rather than pretending the service already has it.
    #[serde(default)]
    pub mounted: bool,
    #[serde(default)]
    pub created_at: Option<String>,
}

/// The Containerfile a service builds with, and how it was arrived at.
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Recipe {
    /// Which strategy wrote it: `nixpacks`, `dockerfile`, `static`…
    pub builder: String,
    /// `generated` until somebody edits it, and `edited` for ever after.
    pub source: String,
    pub containerfile: String,
    #[serde(default)]
    pub exposed_port: Option<u32>,
    #[serde(default)]
    pub notes: Vec<String>,
    #[serde(default)]
    pub warnings: Vec<String>,
}

#[derive(Debug, Deserialize)]
pub struct EditedRecipe {
    pub source: String,
}

#[derive(Debug, Deserialize)]
pub struct ProjectCreated {
    pub project: Project,
}

#[derive(Debug, Deserialize)]
pub struct Disconnected {
    /// How many variable references stopped existing, which is what a
    /// connection was made of in the first place.
    #[serde(default)]
    pub removed: u32,
}

#[derive(Debug, Deserialize)]
pub struct ImportedVariables {
    #[serde(default)]
    pub imported: u32,
}

/// One line of a `.env` on its way to the server.
#[derive(Debug, Serialize)]
pub struct VariableDraft {
    pub key: String,
    pub value: String,
    pub secret: bool,
}