run_stack/

generate.rs

//! The generated compose overlays.
//!
//! Three files are written into .run/ before every up: one shadowing every
//! workspace package's node_modules with a named volume, one adding a service
//! per extra app, and one carrying optional CPU/memory limits. They depend on
//! what the workspace actually contains, so they are regenerated rather than
//! committed.

use std::fs;
use std::path::Path;

use anyhow::{Context, Result};

use crate::config::key_of;
use crate::env::Env;

/// The built-in services that mount the frontend monorepo.
const FRONTEND_SERVICES: &[&str] = &[
    "frontend-deps",
    "frontend-packages",
    "frontend-sync",
    "web",
    "admin",
    "landing",
    "mobile-deps",
    "mobile-packages",
    "mobile-client",
];

const METRO_SERVICES: &[&str] = &["mobile-deps", "mobile-packages", "mobile-client"];

pub fn all(run_dir: &Path, env: &Env, package_dir: &Path) -> Result<()> {
    packages(run_dir, env)?;
    apps(run_dir, env, package_dir)?;
    resources(run_dir, env)?;
    Ok(())
}

/// Every directory holding a package.json, one level under a workspace root.
fn package_dirs(frontend: &Path) -> Vec<String> {
    let mut found = Vec::new();
    for root in ["apps", "packages"] {
        let Ok(entries) = fs::read_dir(frontend.join(root)) else {
            continue;
        };
        for entry in entries.flatten() {
            if entry.path().join("package.json").is_file() {
                found.push(format!(
                    "{root}/{}",
                    entry.file_name().to_string_lossy()
                ));
            }
        }
    }
    found.sort();
    found
}

/// apps/mobile-client -> fe_nm_apps_mobile_client
fn volume_name(dir: &str) -> String {
    format!(
        "fe_nm_{}",
        dir.replace(['/', '-'], "_")
    )
}

fn extra_apps(env: &Env) -> Vec<String> {
    env.get_or("EXTRA_APPS", "")
        .split_whitespace()
        .map(|name| name.split(':').next().unwrap_or(name).to_string())
        .collect()
}

fn mobile_enabled(env: &Env) -> bool {
    env.is_true("RUN_MOBILE", false)
}

/// docker-compose.packages.yml
fn packages(run_dir: &Path, env: &Env) -> Result<()> {
    let frontend = Path::new(env.get_or("FRONTEND_DIR", ""));
    let dirs = package_dirs(frontend);
    let stack = env.get_or("BACKEND_STACK", "laravel").to_string();
    let backend_in_frontend =
        env.get_or("BACKEND_DIR", "").trim_end_matches('/') == env.get_or("FRONTEND_DIR", "").trim_end_matches('/');
    let subdir = env.get_or("BACKEND_SUBDIR", "").trim_end_matches('/').to_string();

    let mut services: Vec<String> = FRONTEND_SERVICES.iter().map(|s| s.to_string()).collect();
    services.extend(extra_apps(env));

    let mut out = String::from("# Generated by run-stack — do not edit.\nservices:\n");

    // A Node backend needs the same treatment; Laravel keeps vendor/ in the
    // bind mount, so there is nothing to shadow there.
    if stack == "node" {
        for service in ["backend", "queue", "scheduler"] {
            out.push_str(&format!("  {service}:\n    volumes:\n"));
            out.push_str("      - pnpm_store:/pnpm-store\n");
            out.push_str("      - fe_nm_root:/app/node_modules\n");
            if backend_in_frontend {
                for dir in &dirs {
                    out.push_str(&format!("      - {}:/app/{dir}/node_modules\n", volume_name(dir)));
                }
                out.push_str("    depends_on:\n      frontend-deps:\n        condition: service_completed_successfully\n");
            } else if !subdir.is_empty() {
                out.push_str(&format!("      - be_node_modules:/app/{subdir}/node_modules\n"));
            }
        }
    }

    for service in &services {
        out.push_str(&format!("  {service}:\n"));
        // With no mobile app, park Metro behind a profile nothing selects. The
        // gate goes in this block: a second mapping for one service in one file
        // is a duplicate key, which compose refuses to parse at all.
        if !mobile_enabled(env) && METRO_SERVICES.contains(&service.as_str()) {
            out.push_str("    profiles: [\"__no_mobile\"]\n");
        }
        if dirs.is_empty() {
            continue;
        }
        out.push_str("    volumes:\n");
        for dir in &dirs {
            out.push_str(&format!("      - {}:/app/{dir}/node_modules\n", volume_name(dir)));
        }
    }

    out.push_str("volumes:\n");
    if stack == "node" && !backend_in_frontend && !subdir.is_empty() {
        out.push_str("  be_node_modules:\n");
    }
    for dir in &dirs {
        out.push_str(&format!("  {}:\n", volume_name(dir)));
    }

    write(run_dir.join("docker-compose.packages.yml"), &out)
}

/// docker-compose.extra.yml — one service per extra app.
///
/// The service definition is not written out by hand: the x-* anchor blocks are
/// copied verbatim out of docker-compose.yml, so an extra app is always built
/// from the same definition as web, admin and landing.
fn apps(run_dir: &Path, env: &Env, package_dir: &Path) -> Result<()> {
    let apps = extra_apps(env);
    let target = run_dir.join("docker-compose.extra.yml");
    if apps.is_empty() {
        let _ = fs::remove_file(&target);
        return Ok(());
    }

    let base = fs::read_to_string(package_dir.join("docker-compose.yml"))
        .with_context(|| format!("reading {}", package_dir.join("docker-compose.yml").display()))?;
    let anchors: String = base
        .lines()
        .skip_while(|line| !line.starts_with("x-"))
        .take_while(|line| !line.starts_with("services:"))
        .map(|line| format!("{line}\n"))
        .collect();

    let frontend = Path::new(env.get_or("FRONTEND_DIR", "")).to_path_buf();
    let mut out = String::from("# Generated by run-stack — do not edit.\n");
    out.push_str("# One service per EXTRA_APPS entry; edit run.config.json and re-run up.\n");
    out.push_str(&anchors);
    out.push_str("services:\n");

    // The shared install covers the built-in apps; EXTRA_DEPS_APPS is the hook
    // that adds these to it.
    out.push_str("  frontend-deps:\n    environment:\n      <<: *frontend-env\n");
    out.push_str(&format!(
        "      EXTRA_DEPS_APPS: \"${{EXTRA_DEPS_APPS:-}} {} \"\n\n",
        apps.join(" ")
    ));

    let mut metro = Vec::new();
    out.push_str("  dashboard:\n    environment:\n");
    out.push_str(&format!("      EXTRA_APPS: \"{}\"\n", env.get_or("EXTRA_APPS", "")));
    for app in &apps {
        out.push_str(&format!(
            "      {}_PORT: \"{}\"\n",
            key_of(app),
            port_of(env, app, &frontend)
        ));
        if is_metro_app(&frontend, app) {
            metro.push(app.clone());
        }
    }
    out.push_str(&format!("      EXTRA_APPS_MOBILE: \"{}\"\n\n", metro.join(" ")));

    for app in &apps {
        let key = key_of(app);
        let port = port_of(env, app, &frontend);
        out.push_str(&format!("  {app}:\n    <<: *frontend-service\n    environment:\n      <<: *frontend-env\n"));
        out.push_str(&format!("      APP_CMD: ${{{key}_CMD:-}}\n"));
        if metro.contains(app) {
            // A second Metro, run exactly like mobile-client.
            out.push_str(&format!("      MOBILE_APP: \"{app}\"\n"));
            out.push_str(&format!("      MOBILE_STACK: ${{{key}_STACK:-auto}}\n"));
            out.push_str("      EXPO_NO_TELEMETRY: \"1\"\n");
            out.push_str("      EXPO_DEVTOOLS_LISTEN_ADDRESS: 0.0.0.0\n");
            out.push_str("      REACT_NATIVE_PACKAGER_HOSTNAME: ${REACT_NATIVE_PACKAGER_HOSTNAME:-localhost}\n");
            out.push_str(&format!("      RCT_METRO_PORT: \"{port}\"\n"));
            out.push_str("      EXPO_PUBLIC_API_BASE_URL: ${EXPO_PUBLIC_API_BASE_URL:-http://localhost:8000/api}\n");
            out.push_str(&format!("    command: [\"metro\", \"{app}\", \"{port}\"]\n"));
        } else {
            out.push_str(&format!("    command: [\"app\", \"{app}\", \"{port}\"]\n"));
        }
        out.push_str(&format!("    ports:\n      - \"{port}:{port}\"\n\n"));
    }

    write(target, &out)
}

/// An app is a Metro app when its own package.json depends on expo or
/// react-native. Nothing in the config says so.
fn is_metro_app(frontend: &Path, app: &str) -> bool {
    let Some(dir) = app_dir(frontend, app) else {
        return false;
    };
    let Ok(text) = fs::read_to_string(dir.join("package.json")) else {
        return false;
    };
    let Ok(package) = serde_json::from_str::<serde_json::Value>(&text) else {
        return false;
    };
    ["dependencies", "devDependencies"].iter().any(|section| {
        package[section]
            .as_object()
            .is_some_and(|deps| {
                deps.keys().any(|name| {
                    name == "expo"
                        || name.starts_with("expo-")
                        || name == "react-native"
                        || name.starts_with("react-native-")
                })
            })
    })
}

fn app_dir(frontend: &Path, app: &str) -> Option<std::path::PathBuf> {
    for root in ["apps", "packages"] {
        let direct = frontend.join(root).join(app);
        if direct.join("package.json").is_file() {
            return Some(direct);
        }
        // The directory and the workspace name need not match.
        if let Ok(entries) = fs::read_dir(frontend.join(root)) {
            for entry in entries.flatten() {
                let manifest = entry.path().join("package.json");
                let Ok(text) = fs::read_to_string(&manifest) else {
                    continue;
                };
                let named = serde_json::from_str::<serde_json::Value>(&text)
                    .ok()
                    .and_then(|package| package["name"].as_str().map(str::to_string));
                if named.as_deref() == Some(app) {
                    return Some(entry.path());
                }
            }
        }
    }
    None
}

fn port_of(env: &Env, app: &str, frontend: &Path) -> u16 {
    let key = format!("{}_PORT", key_of(app));
    if let Some(port) = env.get(&key).and_then(|value| value.trim().parse().ok()) {
        return port;
    }
    if is_metro_app(frontend, app) {
        8082
    } else {
        5180
    }
}

/// docker-compose.resources.yml — only when limits are actually set.
fn resources(run_dir: &Path, env: &Env) -> Result<()> {
    let target = run_dir.join("docker-compose.resources.yml");
    let pick = |specific: &str, global: &str| -> String {
        let value = env.get_or(specific, "");
        if !value.is_empty() {
            return value.to_string();
        }
        env.get_or(global, "").to_string()
    };
    let frontend = (
        pick("FRONTEND_MEMORY_LIMIT", "DOCKER_MEMORY_LIMIT"),
        pick("FRONTEND_CPU_LIMIT", "DOCKER_CPU_LIMIT"),
    );
    let backend = (
        pick("BACKEND_MEMORY_LIMIT", "DOCKER_MEMORY_LIMIT"),
        pick("BACKEND_CPU_LIMIT", "DOCKER_CPU_LIMIT"),
    );
    let postgres = (
        pick("POSTGRES_MEMORY_LIMIT", "DOCKER_MEMORY_LIMIT"),
        pick("POSTGRES_CPU_LIMIT", "DOCKER_CPU_LIMIT"),
    );
    let mysql = (
        pick("MYSQL_MEMORY_LIMIT", "DOCKER_MEMORY_LIMIT"),
        pick("MYSQL_CPU_LIMIT", "DOCKER_CPU_LIMIT"),
    );

    let nothing_set = [&frontend, &backend, &postgres, &mysql]
        .iter()
        .all(|(memory, cpu)| memory.is_empty() && cpu.is_empty());
    if nothing_set {
        // Compose rejects an empty cpus/mem_limit interpolation, so the file
        // exists only when there is something to put in it.
        let _ = fs::remove_file(&target);
        return Ok(());
    }

    let mut out = String::from("# Generated by run-stack — do not edit.\nservices:\n");
    let mut emit = |service: &str, limits: &(String, String)| {
        if limits.0.is_empty() && limits.1.is_empty() {
            return;
        }
        out.push_str(&format!("  {service}:\n"));
        if !limits.0.is_empty() {
            out.push_str(&format!("    mem_limit: {}\n", limits.0));
        }
        if !limits.1.is_empty() {
            out.push_str(&format!("    cpus: {}\n", limits.1));
        }
    };
    for service in FRONTEND_SERVICES.iter().chain(["desktop"].iter()) {
        emit(service, &frontend);
    }
    for app in extra_apps(env) {
        emit(&app, &frontend);
    }
    for service in ["backend", "queue", "scheduler"] {
        emit(service, &backend);
    }
    emit("postgres", &postgres);
    emit("mysql", &mysql);

    write(target, &out)
}

fn write(path: std::path::PathBuf, contents: &str) -> Result<()> {
    if let Some(parent) = path.parent() {
        fs::create_dir_all(parent).with_context(|| format!("creating {}", parent.display()))?;
    }
    fs::write(&path, contents).with_context(|| format!("writing {}", path.display()))
}